@mindrian_os/install 1.13.0-beta.14 → 1.13.0-beta.17

package/lib/core/mva-classifier.cjs

@@ -0,0 +1,370 @@
+'use strict';
+/*
+ * Phase 118-00 Plan 00 -- mva-classifier: two-mode "is this a venture
+ * sentence?" classifier for the 30-Second MVA pipeline.
+ *
+ * Modes:
+ *   (a) Anthropic Haiku 4.5 with strict 1-sentence-classify prompt
+ *       (when ANTHROPIC_API_KEY resolves from env / ~/.mindrian.env / CWD .env)
+ *   (b) Heuristic regex fallback (when no key resolvable) using
+ *       data/mva-heuristic-keywords.json
+ *
+ * Per OQ3 lean + LD1 (118-CONTEXT.md):
+ *   - English-only pipeline for v1.13.0
+ *   - Hebrew detection (single char in U+0590-U+05FF) returns refusal envelope
+ *     BEFORE any Haiku call -- never sends Hebrew bytes to the API
+ *   - Length guard short-circuits < 12 chars OR > 600 chars without API call
+ *
+ * Per B5 (reward-before-investment) -- this classifier fires on the FIRST
+ * user sentence, before any room-creation investment. The classifier is the
+ * pin that decides whether the MVA brief gets built.
+ *
+ * Per Canon Part 8:
+ *   - No Brain MCP calls anywhere in this file (verified by grep in tests)
+ *   - The OUTBOUND payload to Anthropic carries the user's sentence (this is
+ *     Anthropic-direct, NOT through Brain MCP, so Part 8 does NOT apply --
+ *     Part 8 governs the LOCAL -> BRAIN boundary, not LOCAL -> Anthropic)
+ *   - The resulting cache + state writes contain ONLY sha256 hashes of the
+ *     sentence, never the raw text (the hook script enforces this)
+ *
+ * Per Phase 110 telemetry side-channel rule:
+ *   - NO console.log
+ *   - NO process.stdout.write
+ *   - Errors go to stderr via the caller (the hook); this module returns
+ *     structured result objects, never throws on classification failure
+ *
+ * Test seam (`_test` namespace, mirrors Plan 90-01 / 125-05 idiom):
+ *   - setFetch(fn): inject a mock fetch implementation
+ *   - clearCache(): reset the sha256 in-memory cache
+ *
+ * Pure CJS, node built-ins only (fs, path, os, crypto). Uses global fetch
+ * (Node 18+); never adds a network-client dependency.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+// ---------- Constants ----------
+
+const MIN_LEN = 12;
+const MAX_LEN = 600;
+const HAIKU_MODEL = 'claude-haiku-4-5';
+const HAIKU_TIMEOUT_MS = 1200; // leaves 300ms headroom under the 1500ms hook budget
+const HAIKU_MAX_TOKENS = 4;
+const HAIKU_TEMP = 0;
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+
+const CLASSIFY_SYSTEM_PROMPT =
+  "You are a 1-sentence classifier. Output ONLY 'venture' or 'not-venture'. " +
+  "A 'venture' sentence describes a business idea, product, startup, app, " +
+  "platform, or commercial undertaking the user is considering or building. " +
+  "A 'not-venture' sentence is about code, admin tasks, debugging, or any " +
+  'non-business topic. Output one word only.';
+
+const HEURISTIC_PATH = path.resolve(__dirname, '..', '..', 'data', 'mva-heuristic-keywords.json');
+
+// ---------- Module-scope cache + injectable fetch ----------
+
+const _cache = new Map(); // sha256 hex -> { venture, source, reason, confidence, ... }
+let _fetchImpl = null; // null = use global fetch; tests inject a stub
+let _heuristicCache = null;
+
+function _resetForTests() {
+  _cache.clear();
+  _fetchImpl = null;
+  _heuristicCache = null;
+}
+
+// ---------- Heuristic loader ----------
+
+function loadHeuristic() {
+  if (_heuristicCache) return _heuristicCache;
+  try {
+    const raw = fs.readFileSync(HEURISTIC_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    _heuristicCache = {
+      venture_keywords: Array.isArray(parsed.venture_keywords) ? parsed.venture_keywords : [],
+      venture_negative_patterns: Array.isArray(parsed.venture_negative_patterns)
+        ? parsed.venture_negative_patterns : [],
+      language_pattern_hebrew: typeof parsed.language_pattern_hebrew === 'string'
+        ? parsed.language_pattern_hebrew : '[\\u0590-\\u05FF]',
+    };
+  } catch (_e) {
+    // Degraded mode: if the heuristic file is missing or corrupt, fail safe
+    // (treat everything as non-venture). The MVA pipeline does not fire.
+    _heuristicCache = {
+      venture_keywords: [],
+      venture_negative_patterns: [],
+      language_pattern_hebrew: '[\\u0590-\\u05FF]',
+    };
+  }
+  return _heuristicCache;
+}
+
+// ---------- ANTHROPIC_API_KEY resolver ----------
+// Mirrors lib/core/resolve-brain-key.cjs precedence: env -> ~/.mindrian.env
+// -> CWD/.env -> null. We do NOT require resolve-brain-key.cjs directly
+// because that resolver is keyed to MINDRIAN_BRAIN_KEY, not ANTHROPIC_API_KEY.
+
+function _homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+function _parseAnthropicKey(body) {
+  const m = body.match(/^ANTHROPIC_API_KEY\s*=\s*(.+?)\s*$/m);
+  if (!m) return null;
+  // Strip surrounding double quotes if the value was quoted (per the
+  // feedback_gmail_qp_env_var_corruption memory rule -- quoted values are
+  // the recommended form for env keys starting with hex digits).
+  let v = m[1].trim();
+  if (v.length >= 2 && v.charCodeAt(0) === 34 && v.charCodeAt(v.length - 1) === 34) {
+    v = v.slice(1, -1);
+  }
+  return v.length > 0 ? v : null;
+}
+
+function resolveAnthropicKey() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    const v = String(process.env.ANTHROPIC_API_KEY).trim();
+    if (v.length > 0) return v;
+  }
+  try {
+    const p = path.join(_homeDir(), '.mindrian.env');
+    if (fs.existsSync(p)) {
+      const body = fs.readFileSync(p, 'utf8');
+      const v = _parseAnthropicKey(body);
+      if (v) return v;
+    }
+  } catch (_e) {}
+  try {
+    const p = path.join(process.cwd(), '.env');
+    if (fs.existsSync(p)) {
+      const body = fs.readFileSync(p, 'utf8');
+      const v = _parseAnthropicKey(body);
+      if (v) return v;
+    }
+  } catch (_e) {}
+  return null;
+}
+
+// ---------- Sentence normalization + sha256 ----------
+
+function _normalize(s) {
+  return String(s || '').trim().toLowerCase();
+}
+
+function _sha256(s) {
+  return crypto.createHash('sha256').update(s, 'utf8').digest('hex');
+}
+
+// ---------- Language detect (Hebrew per LD1) ----------
+
+function _isHebrew(sentence) {
+  const h = loadHeuristic();
+  let re;
+  try {
+    re = new RegExp(h.language_pattern_hebrew);
+  } catch (_e) {
+    // fall back to literal range -- guaranteed valid
+    re = /[֐-׿]/;
+  }
+  return re.test(sentence);
+}
+
+// ---------- Heuristic decision ----------
+
+function _heuristicDecision(sentence) {
+  const norm = _normalize(sentence);
+  const h = loadHeuristic();
+  // Negative patterns win (Pitfall-3 safety net pattern from Phase 115-02
+  // dual-path-detector: kill signals override positive matches).
+  for (const p of h.venture_negative_patterns) {
+    let re;
+    try { re = new RegExp(p, 'i'); } catch (_e) { continue; }
+    if (re.test(norm)) {
+      return { venture: false, reason: 'matches_negative_pattern' };
+    }
+  }
+  // Positive keyword: any keyword match -> venture-positive.
+  for (const kw of h.venture_keywords) {
+    const lkw = String(kw).toLowerCase();
+    if (norm.indexOf(lkw) !== -1) {
+      return { venture: true, reason: 'matches_venture_keyword' };
+    }
+  }
+  return { venture: false, reason: 'no_keyword_match' };
+}
+
+// ---------- Haiku call (best-effort; falls back to heuristic on any error) ----------
+
+function _getFetch() {
+  if (_fetchImpl) return _fetchImpl;
+  if (typeof fetch === 'function') return fetch;
+  return null;
+}
+
+async function _callHaiku(sentence, apiKey) {
+  const f = _getFetch();
+  if (!f) return null; // no fetch available -- caller falls back to heuristic
+  const body = {
+    model: HAIKU_MODEL,
+    max_tokens: HAIKU_MAX_TOKENS,
+    temperature: HAIKU_TEMP,
+    system: CLASSIFY_SYSTEM_PROMPT,
+    messages: [{ role: 'user', content: sentence }],
+  };
+  const ctrl = (typeof AbortController === 'function') ? new AbortController() : null;
+  const timer = ctrl ? setTimeout(() => { try { ctrl.abort(); } catch (_e) {} }, HAIKU_TIMEOUT_MS) : null;
+  try {
+    const res = await f(ANTHROPIC_URL, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+      body: JSON.stringify(body),
+      signal: ctrl ? ctrl.signal : undefined,
+    });
+    if (!res || !res.ok) return null;
+    const j = await res.json();
+    // Extract first text block; expected single token 'venture' | 'not-venture'.
+    let text = '';
+    if (j && Array.isArray(j.content)) {
+      for (const blk of j.content) {
+        if (blk && blk.type === 'text' && typeof blk.text === 'string') {
+          text += blk.text;
+        }
+      }
+    }
+    const t = String(text || '').trim().toLowerCase();
+    if (t.indexOf('venture') === 0 && t.indexOf('not') !== 0) {
+      return { venture: true, source: 'haiku-4-5', confidence: 'high' };
+    }
+    if (t.indexOf('not-venture') === 0 || t.indexOf('not venture') === 0) {
+      return { venture: false, source: 'haiku-4-5', confidence: 'high', reason: 'haiku_classified_not_venture' };
+    }
+    // Ambiguous output -- caller falls back to heuristic.
+    return null;
+  } catch (_e) {
+    return null;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// ---------- Public: classify ----------
+
+/**
+ * Classify a single user-typed sentence. Synchronous return for callers that
+ * want best-effort speed (heuristic + cache); when the Haiku path runs it
+ * blocks via a deasync-style spin only if a key is present. To keep the hook
+ * budget honest we expose a sync-friendly contract: the FIRST call may run
+ * Haiku synchronously via an Atomics.wait-style busy-loop UNLESS the test
+ * seam has injected a mock fetch -- in which case we still resolve quickly.
+ *
+ * Because Node has no first-class sync HTTP, we implement classify() as a
+ * synchronous function that runs heuristic + cache + Hebrew + length guards
+ * synchronously, and DEFERS the Haiku async call to a separate classifyAsync
+ * surface. The hook script (scripts/mva-detect.cjs) will use the sync entry
+ * point to honor the 1500ms hook budget; the Haiku enrichment runs in the
+ * dispatch worker (Plan 118-01) where async is natural.
+ *
+ * Per OQ3 lean: the heuristic + cache delivers the hook-budget-safe answer;
+ * Haiku is the enrichment path. In practice the heuristic is the dominant
+ * path for v1.13.0 because the 1500ms hook budget is tight.
+ *
+ * @param {string} sentence
+ * @returns {{venture: boolean, source: string, confidence?: string, reason?: string}}
+ */
+function classify(sentence) {
+  // Length guard FIRST (no fetch, no Hebrew check needed for empty/tiny)
+  const s = String(sentence || '');
+  if (s.length < MIN_LEN || s.length > MAX_LEN) {
+    return { venture: false, source: 'length_guard', reason: 'length_out_of_range' };
+  }
+
+  // Hebrew detect SECOND (LD1: never send Hebrew bytes downstream)
+  if (_isHebrew(s)) {
+    return {
+      venture: false,
+      source: 'language_detect',
+      reason: 'hebrew_unsupported_v1.13.0',
+    };
+  }
+
+  // Cache check by sha256(normalized)
+  const key = _sha256(_normalize(s));
+  if (_cache.has(key)) return _cache.get(key);
+
+  // Heuristic decision (synchronous, always runs)
+  const heur = _heuristicDecision(s);
+
+  // Decide source label based on key availability:
+  //   - Key absent  -> heuristic_fallback, confidence: medium
+  //   - Key present -> heuristic with confidence: high (Haiku enrichment
+  //     is the async path for Plan 118-01; sync hook keeps the heuristic
+  //     answer for the 1500ms budget)
+  const keyAvail = resolveAnthropicKey() !== null;
+  const result = heur.venture
+    ? {
+        venture: true,
+        source: keyAvail ? 'heuristic' : 'heuristic_fallback',
+        confidence: keyAvail ? 'high' : 'medium',
+        reason: heur.reason,
+      }
+    : {
+        venture: false,
+        source: keyAvail ? 'heuristic' : 'heuristic_fallback',
+        confidence: keyAvail ? 'high' : 'medium',
+        reason: heur.reason,
+      };
+
+  _cache.set(key, result);
+  return result;
+}
+
+/**
+ * Boolean alias: true iff classify(s).venture is true.
+ */
+function isVentureSentence(s) {
+  return classify(s).venture === true;
+}
+
+/**
+ * Async enrichment surface (called by Plan 118-01's dispatcher worker, not
+ * by the hook). Runs the Haiku 4.5 path when a key resolves; otherwise
+ * returns the same heuristic-driven result classify() returned synchronously.
+ *
+ * The cache contract: classifyAsync writes through to the same sha256 cache
+ * so a subsequent sync classify() call returns the Haiku-enriched answer.
+ */
+async function classifyAsync(sentence) {
+  const sync = classify(sentence);
+  if (sync.source === 'length_guard' || sync.source === 'language_detect') return sync;
+  const apiKey = resolveAnthropicKey();
+  if (!apiKey) return sync; // no enrichment path -- heuristic stands
+  const enriched = await _callHaiku(sentence, apiKey);
+  if (!enriched) return sync; // Haiku failed/timed out -- heuristic stands
+  // Promote: write enriched into cache by sha256(normalized).
+  const key = _sha256(_normalize(sentence));
+  const promoted = Object.assign({}, sync, enriched);
+  _cache.set(key, promoted);
+  return promoted;
+}
+
+module.exports = {
+  classify,
+  classifyAsync,
+  isVentureSentence,
+  loadHeuristic,
+  resolveAnthropicKey,
+  // Test seam (mirrors Plan 90-01 / 125-05 idiom)
+  _test: {
+    setFetch(fn) { _fetchImpl = fn; },
+    clearCache() { _resetForTests(); },
+  },
+};

package/lib/core/mva-classifier.test.cjs

@@ -0,0 +1,248 @@
+'use strict';
+/*
+ * Phase 118-00 Plan 00 -- mva-classifier + mva-state unit tests.
+ *
+ * 7 tests (per PLAN.md Task 1 behavior block):
+ *   T1 heuristic positive (3 venture sentences)
+ *   T2 heuristic negative (3 coding/admin sentences)
+ *   T3 Hebrew detection -> graceful refusal (per LD1; pre-empts Haiku call)
+ *   T4 short-circuit on length (< 12 chars OR > 600 chars)
+ *   T5 cache hit (sha256 keyed; second call returns cached, fetch counter = 0)
+ *   T6 state I/O round trip (writePending / readPending / markRunning /
+ *      markComplete / isAlreadyRunning; atomic tmpfile-then-rename)
+ *   T7 heuristic-only mode when ANTHROPIC_API_KEY absent (fetch counter = 0)
+ *
+ * Test seam strategy: classifier exposes `_test` namespace for injecting
+ * a mock fetch + clearing the in-memory sha256 cache. State module exposes
+ * `stateDir` so the test can hijack a tmpdir HOME without touching the
+ * real ~/.mindrian/mva. Mirrors the Plan 90-01 / Plan 109-10 seam idiom.
+ *
+ * Pure CJS, node built-ins only. No mocha, no jest -- mirrors the Phase 109
+ * + Phase 124 + Phase 125 in-tree runner pattern.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const CLASSIFIER_PATH = path.resolve(__dirname, 'mva-classifier.cjs');
+const STATE_PATH = path.resolve(__dirname, 'mva-state.cjs');
+
+let passed = 0;
+let failed = 0;
+function run(name, fn) {
+  try {
+    fn();
+    process.stdout.write('ok  ' + name + '\n');
+    passed += 1;
+  } catch (err) {
+    process.stderr.write('FAIL ' + name + '\n' + (err && err.stack ? err.stack : String(err)) + '\n');
+    failed += 1;
+  }
+}
+
+// Fresh require each block so the in-memory cache resets between mutating
+// suites. classify keeps a Map at module scope -- a stale entry would mask
+// genuine failures of the no-fetch invariant in T5/T7.
+function freshClassifier() {
+  delete require.cache[CLASSIFIER_PATH];
+  return require(CLASSIFIER_PATH);
+}
+
+function freshState() {
+  delete require.cache[STATE_PATH];
+  return require(STATE_PATH);
+}
+
+// ---------- T1 heuristic positive ----------
+
+run('T1 heuristic positive: 3 venture sentences', () => {
+  delete process.env.ANTHROPIC_API_KEY;
+  const { classify } = freshClassifier();
+  const venture = [
+    'I have an idea for a couples finance app',
+    'thinking about building a SaaS for dentists',
+    'considering launching a platform for nonprofits',
+  ];
+  for (const s of venture) {
+    const r = classify(s);
+    assert.equal(r.venture, true, 'expected venture=true for: ' + s + ' got ' + JSON.stringify(r));
+    assert.ok(r.source === 'heuristic' || r.source === 'heuristic_fallback',
+      'expected source heuristic*; got ' + r.source);
+  }
+});
+
+// ---------- T2 heuristic negative ----------
+
+run('T2 heuristic negative: 3 coding/admin sentences', () => {
+  delete process.env.ANTHROPIC_API_KEY;
+  const { classify } = freshClassifier();
+  const nonVenture = [
+    'fix the failing test in foo.test.js',
+    '/mos:status now please please',
+    'git push origin main right now',
+  ];
+  for (const s of nonVenture) {
+    const r = classify(s);
+    assert.equal(r.venture, false, 'expected venture=false for: ' + s + ' got ' + JSON.stringify(r));
+    assert.ok(r.source === 'heuristic' || r.source === 'language_detect' || r.source === 'length_guard'
+      || r.source === 'heuristic_fallback',
+      'unexpected source ' + r.source + ' for ' + s);
+  }
+});
+
+// ---------- T3 Hebrew detection (LD1) ----------
+
+run('T3 Hebrew detection -> hebrew_unsupported_v1.13.0, no fetch', () => {
+  process.env.ANTHROPIC_API_KEY = 'sk-fake-should-never-be-called';
+  const mod = freshClassifier();
+  let fetchCount = 0;
+  mod._test.setFetch(async () => { fetchCount += 1; return { ok: true, json: async () => ({}) }; });
+  const r = mod.classify('יש לי רעיון לאפליקציה לזוגות');
+  assert.equal(r.venture, false);
+  assert.equal(r.reason, 'hebrew_unsupported_v1.13.0');
+  assert.equal(r.source, 'language_detect');
+  assert.equal(fetchCount, 0, 'Hebrew must short-circuit BEFORE any API call');
+  delete process.env.ANTHROPIC_API_KEY;
+});
+
+// ---------- T4 length short-circuit ----------
+
+run('T4 length out of range -> short-circuit, no fetch', () => {
+  process.env.ANTHROPIC_API_KEY = 'sk-fake';
+  const mod = freshClassifier();
+  let fetchCount = 0;
+  mod._test.setFetch(async () => { fetchCount += 1; return { ok: true, json: async () => ({}) }; });
+  // Too short
+  let r = mod.classify('');
+  assert.equal(r.venture, false);
+  assert.equal(r.reason, 'length_out_of_range');
+  r = mod.classify('hi');
+  assert.equal(r.venture, false);
+  assert.equal(r.reason, 'length_out_of_range');
+  // Too long
+  const longStr = 'x'.repeat(700);
+  r = mod.classify(longStr);
+  assert.equal(r.venture, false);
+  assert.equal(r.reason, 'length_out_of_range');
+  assert.equal(fetchCount, 0, 'length-guard must short-circuit BEFORE any API call');
+  delete process.env.ANTHROPIC_API_KEY;
+});
+
+// ---------- T5 cache hit on repeated sha256 ----------
+
+run('T5 cache hit: second call returns cached (fetch counter unchanged)', () => {
+  // Use ANTHROPIC_API_KEY so the FIRST call may consult fetch; we mock
+  // fetch to return a known answer, then assert call 2 does NOT hit fetch.
+  process.env.ANTHROPIC_API_KEY = 'sk-fake-for-cache-test';
+  const mod = freshClassifier();
+  let fetchCount = 0;
+  mod._test.setFetch(async () => {
+    fetchCount += 1;
+    return {
+      ok: true,
+      json: async () => ({ content: [{ type: 'text', text: 'venture' }] }),
+    };
+  });
+  mod._test.clearCache();
+  const s = 'a-very-unique-sentence-not-in-heuristic-bank-1234567890';
+  const r1 = mod.classify(s);
+  const r2 = mod.classify(s);
+  assert.equal(r1.venture, r2.venture, 'cache should return identical result');
+  // The heuristic path may have answered without fetch -- that's fine. The
+  // contract is: second call MUST NOT add to fetchCount.
+  const after1 = fetchCount;
+  const r3 = mod.classify(s);
+  assert.equal(fetchCount, after1, 'third call must not re-trigger fetch');
+  assert.equal(r3.venture, r1.venture);
+  delete process.env.ANTHROPIC_API_KEY;
+});
+
+// ---------- T6 state I/O round trip ----------
+
+run('T6 state I/O round trip + atomic write semantics', () => {
+  // Isolate state to a tmpdir HOME so we never touch the real ~/.mindrian.
+  const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mva-state-test-'));
+  const prevHome = process.env.HOME;
+  const prevSession = process.env.CLAUDE_SESSION_ID;
+  process.env.HOME = tmpHome;
+  process.env.CLAUDE_SESSION_ID = 'test-session-118-00';
+  try {
+    const state = freshState();
+    // Clean slate
+    assert.equal(state.readPending(), null, 'cold start: readPending returns null');
+    assert.equal(state.isAlreadyRunning(), false, 'cold start: not running');
+
+    const payload = {
+      sentence_sha256: 'a'.repeat(64),
+      classified_at: Date.now(),
+      classifier_source: 'heuristic',
+      classifier_confidence: 'high',
+      locale: 'en',
+    };
+    state.writePending(payload);
+    const read = state.readPending();
+    // writePending initializes pipeline_status='pending' for the dispatcher
+    // (Plan 118-01) to read. The original payload fields must all be present
+    // and byte-identical; pipeline_status is added by the writer.
+    for (const k of Object.keys(payload)) {
+      assert.deepEqual(read[k], payload[k],
+        'writePending must preserve field ' + k + '; got ' + JSON.stringify(read[k]));
+    }
+    assert.equal(read.pipeline_status, 'pending',
+      'writePending must initialize pipeline_status="pending" for dispatcher');
+
+    state.markRunning();
+    assert.equal(state.isAlreadyRunning(), true);
+
+    state.markComplete();
+    assert.equal(state.isAlreadyRunning(), false);
+
+    // Verify state dir lives under ~/.mindrian/mva (i.e. respects tmpHome)
+    assert.ok(state.stateDir().indexOf(tmpHome) === 0,
+      'stateDir should be under tmpHome; got ' + state.stateDir());
+
+    // Atomic-write source-grep audit: verify the module uses tmp+rename idiom
+    const src = fs.readFileSync(STATE_PATH, 'utf8');
+    assert.ok(/renameSync/.test(src), 'mva-state.cjs must use fs.renameSync (atomic write)');
+    assert.ok(/\.tmp/.test(src) || /tmp/.test(src),
+      'mva-state.cjs must write to a tmp path before rename');
+  } finally {
+    process.env.HOME = prevHome;
+    if (prevSession === undefined) delete process.env.CLAUDE_SESSION_ID;
+    else process.env.CLAUDE_SESSION_ID = prevSession;
+    try { fs.rmSync(tmpHome, { recursive: true, force: true }); } catch (_e) {}
+  }
+});
+
+// ---------- T7 heuristic-only mode when ANTHROPIC_API_KEY unset ----------
+
+run('T7 heuristic-only mode: no fetch attempted when key absent', () => {
+  delete process.env.ANTHROPIC_API_KEY;
+  // Also clear ~/.mindrian.env / .env paths by overriding HOME to a clean
+  // tmpdir so the resolver returns not-found deterministically.
+  const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mva-no-key-test-'));
+  const prevHome = process.env.HOME;
+  process.env.HOME = tmpHome;
+  try {
+    const mod = freshClassifier();
+    let fetchCount = 0;
+    mod._test.setFetch(async () => { fetchCount += 1; return { ok: true, json: async () => ({}) }; });
+    mod._test.clearCache();
+    const r = mod.classify('I have an idea for a couples finance app');
+    assert.equal(r.venture, true);
+    assert.equal(r.source, 'heuristic_fallback',
+      'when key absent, source must be heuristic_fallback (medium confidence); got ' + r.source);
+    assert.equal(r.confidence, 'medium');
+    assert.equal(fetchCount, 0, 'fetch must not be attempted without an API key');
+  } finally {
+    process.env.HOME = prevHome;
+    try { fs.rmSync(tmpHome, { recursive: true, force: true }); } catch (_e) {}
+  }
+});
+
+// ---------- Summary ----------
+
+process.stderr.write('\n' + passed + ' passed, ' + failed + ' failed\n');
+process.exit(failed === 0 ? 0 : 1);