kenaz 0.0.0-stage → 0.3.2

package/core/.specialist/Ansuz/tools/ansuz-sdk-runner.js

@@ -0,0 +1,1254 @@
+/**
+ * Ansuz SDK Runner — TASK_912
+ * Uses @anthropic-ai/claude-agent-sdk for multi-turn Ansuz conversation.
+ *
+ * Flow:
+ *   1. Build Ansuz assembled prompt (Phase 0 wake context)
+ *   2. Start first query → capture sessionId → write ansuz_session.json
+ *   3. Poll ansuz_inbox.json for user messages → resume sessionId
+ *   4. Stream output lands in JSONL → ansuz_daemon tails it → SSE → AnsuzFloat
+ *
+ * Usage:
+ *   node ansuz-sdk-runner.js --project-path=D:\Projects\KenazAI
+ */
+
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+const http = require('http');
+// TASK_1094: lazy-load the SDK so this module can be required by tests in
+// environments where @anthropic-ai/claude-agent-sdk is not installed.
+// `query` is only used inside runQuery() — the daemon path still loads it on first use.
+let _sdkQuery = null;
+function query(...args) {
+  if (!_sdkQuery) {
+    _sdkQuery = require('@anthropic-ai/claude-agent-sdk').query;
+  }
+  return _sdkQuery(...args);
+}
+const ansuzState = require('./ansuz-state');
+
+// ── CLI args ──────────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const projectPath = (() => {
+  const flag = args.find(a => a.startsWith('--project-path='));
+  return flag ? flag.split('=').slice(1).join('=') : process.cwd();
+})();
+
+const ROOT = projectPath;
+const KENAZ_HTTP_PORT = process.env.KENAZ_HTTP_PORT || '18080';
+const MCP_URL = `http://localhost:${KENAZ_HTTP_PORT}/api/rust/mcp`;
+
+const SESSION_JSON         = path.join(ROOT, '.kenaz', 'specialist', 'ansuz_session.json');
+const INBOX_JSON           = path.join(ROOT, '.kenaz', 'specialist', 'ansuz_inbox.json');
+const AMBIENT_SIGNALS_JSON = path.join(ROOT, '.kenaz', 'specialist', 'ambient_signals.json');
+const PID_FILE             = path.join(ROOT, '.kenaz', 'specialist', 'ansuz_pid.txt');
+const RESTART_BLOCK_JSON   = path.join(ROOT, '.kenaz', 'specialist', 'ansuz_restart_block.json');
+const LOG_FILE             = path.join(ROOT, '.kenaz', 'logs', 'ansuz-sdk-runner.log');
+
+const ATTENTION_BUFFER_JSON = path.join(ROOT, '.kenaz', 'specialist', 'attention_buffer.json');
+const HUGINN_ATTENTION_JSON = path.join(ROOT, '.kenaz', 'huginn-attention.json');
+const DAEMON_OUTBOX_JSON    = path.join(ROOT, '.kenaz', 'specialist', 'daemon_outbox.json');
+const BACKGROUND_LOOP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_AMBIENT_SIGNALS = 10;
+const ATTENTION_HALFLIFE_MS = 12 * 60 * 60 * 1000; // 12 hours
+const ATTENTION_FLOOR = 0.01;
+// TASK_1094: replace-if-recent window. If the same source re-fires within this window,
+// addSignal REPLACES the existing weight instead of compounding it. Prevents the
+// time-accumulation pathology where a long-lived sub-threshold signal asymptotes
+// upward indefinitely (observed: a review signal escalating 1.197 → 8.14 over 50min).
+// Default 10 min = 2× the normal 5min cognitive cycle, so a single source repeating
+// every cycle is treated as one ongoing observation, not new evidence each tick.
+// Different sources within the same window still compound (cross-sensor evidence).
+const REPLACE_WINDOW_MS = 10 * 60 * 1000;
+const MCP_FAST_TIMEOUT_MS = 5000; // 5s fail-fast for new MCP signal sources
+// ── AttentionBuffer — weighted signal aggregation (TASK_964) ─────────────────
+class AttentionBuffer {
+  constructor() {
+    /** @type {Map<string, {weight: number, lastUpdated: number, source: string, meta?: object}>} */
+    this.signals = new Map();
+    this.prevEfeSnapshot = null;
+    this._load();
+  }
+
+  /** Load persisted state from attention_buffer.json */
+  _load() {
+    try {
+      if (fs.existsSync(ATTENTION_BUFFER_JSON)) {
+        const data = JSON.parse(fs.readFileSync(ATTENTION_BUFFER_JSON, 'utf8'));
+        if (Array.isArray(data.signals)) {
+          for (const entry of data.signals) {
+            this.signals.set(entry.symbol, {
+              weight: entry.weight,
+              lastUpdated: entry.lastUpdated,
+              source: entry.source || 'unknown',
+              meta: entry.meta,
+            });
+          }
+        }
+        if (data.prevEfeSnapshot != null) {
+          this.prevEfeSnapshot = data.prevEfeSnapshot;
+        }
+      }
+    } catch (e) {
+      log(`[AttentionBuffer] Warning: failed to load: ${e.message}`);
+    }
+  }
+
+  /** Persist current state to attention_buffer.json */
+  persist() {
+    try {
+      const entries = [];
+      for (const [symbol, entry] of this.signals) {
+        entries.push({ symbol, ...entry });
+      }
+      const data = {
+        version: 1,
+        updated_at: new Date().toISOString(),
+        prevEfeSnapshot: this.prevEfeSnapshot,
+        signals: entries,
+      };
+      fs.mkdirSync(path.dirname(ATTENTION_BUFFER_JSON), { recursive: true });
+      fs.writeFileSync(ATTENTION_BUFFER_JSON, JSON.stringify(data, null, 2));
+    } catch (e) {
+      log(`[AttentionBuffer] Warning: failed to persist: ${e.message}`);
+    }
+  }
+
+  /**
+   * Add or update a signal for a symbol.
+   *
+   * TASK_1094: replace-if-recent semantics. If the same source re-fires within
+   * REPLACE_WINDOW_MS, the existing weight is REPLACED (not compounded) — same
+   * source repeating in the window represents one ongoing observation, not new
+   * evidence each tick. A different source within the window still compounds
+   * with the decayed existing weight (cross-sensor compounding preserved).
+   *
+   * @param {string} symbol - Symbol identifier
+   * @param {number} weight - Signal weight (positive)
+   * @param {string} source - Signal source (e.g. 'heat', 'curiosity', 'risk')
+   * @param {object} [meta] - Optional metadata
+   */
+  addSignal(symbol, weight, source, meta) {
+    const now = Date.now();
+    const newWeight = Math.max(0, weight);
+    const existing = this.signals.get(symbol);
+    if (existing) {
+      const dt = now - existing.lastUpdated;
+      const sameSourceRecent = existing.source === source && dt < REPLACE_WINDOW_MS;
+      if (sameSourceRecent) {
+        // replace-if-recent: same source within window → overwrite, do not compound
+        existing.weight = newWeight;
+      } else {
+        // Cross-source within window OR same source after window → decay then add
+        const decayed = this._decay(existing.weight, dt);
+        existing.weight = decayed + newWeight;
+      }
+      existing.lastUpdated = now;
+      existing.source = source;
+      if (meta) existing.meta = meta;
+    } else {
+      this.signals.set(symbol, {
+        weight: newWeight,
+        lastUpdated: now,
+        source,
+        meta,
+      });
+    }
+  }
+
+  /**
+   * Apply exponential decay: w * 2^(-dt/halflife)
+   * @param {number} w - Current weight
+   * @param {number} dtMs - Time delta in milliseconds
+   * @returns {number} Decayed weight
+   */
+  _decay(w, dtMs) {
+    if (dtMs <= 0) return w;
+    return w * Math.pow(2, -dtMs / ATTENTION_HALFLIFE_MS);
+  }
+
+  /**
+   * Decay all signals in-place and evict those below the floor.
+   * Called during each cognitive cycle.
+   */
+  _decayAll() {
+    const now = Date.now();
+    const toDelete = [];
+    for (const [symbol, entry] of this.signals) {
+      entry.weight = this._decay(entry.weight, now - entry.lastUpdated);
+      entry.lastUpdated = now;
+      if (entry.weight < ATTENTION_FLOOR) {
+        toDelete.push(symbol);
+      }
+    }
+    for (const symbol of toDelete) {
+      this.signals.delete(symbol);
+    }
+  }
+
+  /**
+   * Get aggregated (decayed) weight for a symbol.
+   * @param {string} symbol
+   * @returns {number} Current decayed weight, or 0 if not present
+   */
+  getAggregatedWeight(symbol) {
+    const entry = this.signals.get(symbol);
+    if (!entry) return 0;
+    return this._decay(entry.weight, Date.now() - entry.lastUpdated);
+  }
+
+  /**
+   * Get top N signals sorted by decayed weight descending.
+   * @param {number} n - Number of signals to return
+   * @returns {Array<{symbol: string, weight: number, source: string, meta?: object}>}
+   */
+  getTopSignals(n = 10) {
+    const now = Date.now();
+    const results = [];
+    for (const [symbol, entry] of this.signals) {
+      const decayed = this._decay(entry.weight, now - entry.lastUpdated);
+      if (decayed >= ATTENTION_FLOOR) {
+        results.push({ symbol, weight: decayed, source: entry.source, meta: entry.meta });
+      }
+    }
+    results.sort((a, b) => b.weight - a.weight);
+    return results.slice(0, n);
+  }
+
+  /** Store EFE snapshot for cross-cycle comparison */
+  setEfeSnapshot(snapshot) {
+    this.prevEfeSnapshot = snapshot;
+  }
+
+  /** Retrieve previous EFE snapshot */
+  getEfeSnapshot() {
+    return this.prevEfeSnapshot;
+  }
+}
+
+// Singleton instance
+const attentionBuffer = new AttentionBuffer();
+
+// ── Logging ───────────────────────────────────────────────────────────────────
+fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}`;
+  console.log(line);
+  fs.appendFileSync(LOG_FILE, line + '\n');
+}
+
+function classifySdkFailure(error) {
+  const message = String(error?.message || error || '');
+  const lower = message.toLowerCase();
+  const isQuotaLike =
+    lower.includes('hit your limit') ||
+    lower.includes('rate limit') ||
+    lower.includes('quota') ||
+    lower.includes('credits') ||
+    lower.includes('usage limit') ||
+    lower.includes('too many requests');
+
+  const classification = {
+    message,
+    shouldBlockRestart: isQuotaLike,
+    reason: isQuotaLike ? 'sdk_quota_exhausted' : 'unknown',
+    blockedUntil: null,
+  };
+
+  const resetMatch = message.match(/resets?\s+([A-Z][a-z]{2}\s+\d{1,2},\s+\d{1,2}(?::\d{2})?\s*(?:am|pm))/i);
+  if (isQuotaLike && resetMatch) {
+    const candidate = `${resetMatch[1]} GMT+0800`;
+    const parsed = new Date(candidate);
+    if (!Number.isNaN(parsed.getTime())) {
+      classification.blockedUntil = parsed.toISOString();
+    }
+  }
+
+  if (isQuotaLike && !classification.blockedUntil) {
+    classification.blockedUntil = new Date(Date.now() + 12 * 60 * 60 * 1000).toISOString();
+  }
+
+  return classification;
+}
+
+function writeRestartBlock(details) {
+  try {
+    fs.mkdirSync(path.dirname(RESTART_BLOCK_JSON), { recursive: true });
+    fs.writeFileSync(RESTART_BLOCK_JSON, JSON.stringify({
+      schema_version: 1,
+      reason: details.reason,
+      blocked_until: details.blockedUntil,
+      message: details.message,
+      detected_at: new Date().toISOString(),
+      source: 'ansuz-sdk-runner',
+    }, null, 2));
+    log(`[RestartBlock] Wrote restart block (${details.reason}) until ${details.blockedUntil || 'manual clear'}`);
+  } catch (e) {
+    log(`[RestartBlock] Failed to write restart block: ${e.message}`);
+  }
+}
+
+function clearRestartBlock() {
+  try {
+    if (fs.existsSync(RESTART_BLOCK_JSON)) {
+      fs.unlinkSync(RESTART_BLOCK_JSON);
+      log('[RestartBlock] Cleared restart block after successful SDK startup');
+    }
+  } catch (e) {
+    log(`[RestartBlock] Failed to clear restart block: ${e.message}`);
+  }
+}
+
+// ── Build prompt ──────────────────────────────────────────────────────────────
+async function buildWakePrompt() {
+  // session.js lives in KenazAI core — use __dirname (this file's location) to find it
+  const coreRoot = path.resolve(__dirname, '../../..');
+  const sessionModule = require(path.join(coreRoot, '.specialist', 'tools', 'session'));
+  let prompt;
+  try {
+    // elixir, same persona as /Ansuz and Bifrost (kernel retired as a default 2026-09-23).
+    prompt = await sessionModule.buildPrompt('Ansuz', { mode: 'assembled', depth: 'elixir' });
+  } catch (e) {
+    log(`[ERROR] buildPrompt failed: ${e.message}`);
+    throw e;
+  }
+
+  prompt += '\n\n# ═══ WAKE-UP CONTEXT ═══\n';
+  prompt += `project_path: ${ROOT}\n`;
+  prompt += `core_path: ${coreRoot}\n`;
+  prompt += `woken_at: ${new Date().toISOString()}\n`;
+  prompt += `runner: ansuz-sdk-runner (multi-turn SDK mode)\n`;
+  prompt += `\n# IMPORTANT: All .specialist/ and .collaboration/ tools live in core_path, not project_path.\n`;
+  prompt += `# Use: cd "${coreRoot}" && node .specialist/tools/phase-gate.js ...\n`;
+  prompt += `# Use: cd "${coreRoot}" && node .collaboration/core/task-api.js --project-path="${ROOT}" ...\n`;
+
+  // Inject state via ansuz-state (handles schema migration + full formatting)
+  try {
+    const state = ansuzState.readState(ROOT);
+    const formatted = ansuzState.formatStateForPrompt(state);
+    if (formatted) {
+      prompt += '\n' + formatted + '\n';
+    }
+  } catch { /* ignore */ }
+
+  // Inject ISBAR handoff (via readLatestHandoff for stale guard + project validation)
+  try {
+    const ansuzHandoff = require('./ansuz-handoff');
+    const handoff = ansuzHandoff.readLatestHandoff(ROOT);
+    if (handoff) {
+      const isbar = handoff.isbar || {};
+      prompt += '\n## ISBAR Handoff (previous session)\n';
+      if (handoff.session_id)       prompt += `session_id: ${handoff.session_id}\n`;
+      if (handoff.created_at)       prompt += `created_at: ${handoff.created_at}\n`;
+      if (handoff.triggered_by)     prompt += `triggered_by: ${handoff.triggered_by}\n`;
+      if (isbar.identity)           prompt += `identity: ${isbar.identity}\n`;
+      if (isbar.situation)          prompt += `situation: ${isbar.situation}\n`;
+      if (isbar.background)         prompt += `background: ${isbar.background}\n`;
+      if (isbar.assessment)         prompt += `assessment: ${isbar.assessment}\n`;
+      if (isbar.recommendation)     prompt += `recommendation: ${isbar.recommendation}\n`;
+    }
+  } catch { /* ignore */ }
+
+  prompt += '\n## Wake Directive\n';
+  prompt += 'You have been woken by the Kenaz Dashboard SDK runner. Run Phase 0, ' +
+    'review the state above, and handle any pending observations or tasks. ' +
+    'This is a multi-turn session — after Phase 0, await user input and respond naturally.\n';
+
+  return prompt;
+}
+
+// ── Ambient signals helpers ───────────────────────────────────────────────────
+function readAmbientSignals() {
+  try {
+    if (!fs.existsSync(AMBIENT_SIGNALS_JSON)) return [];
+    const data = JSON.parse(fs.readFileSync(AMBIENT_SIGNALS_JSON, 'utf8'));
+    return Array.isArray(data.signals) ? data.signals : [];
+  } catch { return []; }
+}
+
+function writeAmbientSignals(signals) {
+  try {
+    const trimmed = signals.slice(-MAX_AMBIENT_SIGNALS);
+    fs.mkdirSync(path.dirname(AMBIENT_SIGNALS_JSON), { recursive: true });
+    // TASK_1095: atomic write via .tmp + rename so a crash mid-write cannot leave
+    // a half-serialized file on disk. On Windows, fs.renameSync can fail with EPERM
+    // or EBUSY when the target is open by another process (e.g. Ansuz reading it
+    // concurrently) — retry up to 3 times with a 100ms backoff (GEN-009).
+    const tmpPath = AMBIENT_SIGNALS_JSON + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify({ signals: trimmed }, null, 2));
+    let lastErr = null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        fs.renameSync(tmpPath, AMBIENT_SIGNALS_JSON);
+        lastErr = null;
+        break;
+      } catch (e) {
+        lastErr = e;
+        if (e.code !== 'EPERM' && e.code !== 'EBUSY' && e.code !== 'EACCES') break;
+        // Busy-wait 100ms (sync path — already inside the background loop)
+        const deadline = Date.now() + 100;
+        while (Date.now() < deadline) { /* spin */ }
+      }
+    }
+    if (lastErr) {
+      // Fallback: clean up tmp and surface the error
+      try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+      throw lastErr;
+    }
+  } catch (e) {
+    log(`[BG] Warning: failed to write ambient_signals.json: ${e.message}`);
+  }
+}
+
+function dedupeAndMergeAmbientSignal(existing, newSignal) {
+  const merged = Array.isArray(existing) ? [...existing] : [];
+  const newPrimarySymbol = Array.isArray(newSignal?.symbols) ? newSignal.symbols[0] : undefined;
+  const matchIndex = merged.findIndex(signal =>
+    signal?.signal_type === newSignal?.signal_type &&
+    (Array.isArray(signal?.symbols) ? signal.symbols[0] : undefined) === newPrimarySymbol
+  );
+
+  if (matchIndex >= 0) {
+    merged[matchIndex] = newSignal;
+  } else {
+    merged.push(newSignal);
+  }
+
+  return merged;
+}
+
+// ── Ambient signal reconciliation (TASK_1095) ────────────────────────────────
+/**
+ * Clear stale ambient signals + attention buffer entries when a signal source
+ * reports "no longer live". This prevents the daemon from reconciling against
+ * its own stale signals in subsequent cycles.
+ *
+ * I1 fix: ambient_signals.json entries never expired when the source state
+ * cleared — they lingered up to 50 minutes (until MAX_AMBIENT_SIGNALS trim).
+ *
+ * Critical addition (Amelia review): even after I2 (TASK_1094) fixes the
+ * weight-accumulation pathology, if an AttentionBuffer entry still carries
+ * weight from prior accumulation, Grade 4 routing will keep re-appending the
+ * signal. Buffer eviction for the affected symbols is the only way to stop
+ * the escalation loop.
+ *
+ * @param {string} signalType - e.g. 'pending_proposals', 'due_episodes'
+ * @param {boolean} isLive - true = source still firing; false = source cleared
+ * @param {string[]} affectedSymbols - symbols to evict from attentionBuffer
+ */
+function reconcileSignalSource(signalType, isLive, affectedSymbols) {
+  if (isLive) return;
+  try {
+    // Step 1: drop matching entries from ambient_signals.json
+    const existing = readAmbientSignals();
+    const filtered = existing.filter(s => s && s.signal_type !== signalType);
+    if (filtered.length !== existing.length) {
+      writeAmbientSignals(filtered);
+      log(`[BG] Reconcile: cleared ${existing.length - filtered.length} stale '${signalType}' entry/ies from ambient_signals.json`);
+    }
+    // Step 2: evict affected symbols from attentionBuffer to stop re-escalation.
+    // Without this, a stale weight from prior cycles keeps Grade 4 routing
+    // re-appending the signal every tick (see TASK_1094 post-mortem).
+    for (const sym of (affectedSymbols || [])) {
+      if (attentionBuffer.signals.delete(sym)) {
+        log(`[BG] Reconcile: evicted '${sym}' from attentionBuffer (source '${signalType}' cleared)`);
+      }
+    }
+    // Step 3: retract daemon_outbox notifications from the cleared source (TASK_1728).
+    retractOutboxBySignalType(signalType);
+  } catch (e) {
+    log(`[BG] Warning: reconcileSignalSource('${signalType}') failed: ${e.message}`);
+  }
+}
+
+/**
+ * Remove or trim daemon_outbox.json notifications originating from a cleared signal
+ * source. Called by reconcileSignalSource(signalType, isLive=false).
+ *
+ * Semantics (simplest correct):
+ *   - Pure notifications (all signals of signalType): removed entirely.
+ *   - Mixed notifications (signals from other types too): signals of signalType are
+ *     stripped; notification survives if at least one other signal remains.
+ *
+ * This prevents stale outbox entries from replaying into fresh sessions after
+ * source-clear (e.g. pending_proposals drops to 0 after queue hygiene).
+ *
+ * @param {string} signalType - e.g. 'pending_proposals', 'due_episodes'
+ */
+function retractOutboxBySignalType(signalType) {
+  try {
+    if (!fs.existsSync(DAEMON_OUTBOX_JSON)) return;
+    const raw = fs.readFileSync(DAEMON_OUTBOX_JSON, 'utf8');
+    const data = JSON.parse(raw);
+    if (!Array.isArray(data.notifications) || data.notifications.length === 0) return;
+
+    const retracted = [];
+    data.notifications = data.notifications
+      .map(n => {
+        if (!Array.isArray(n.signals)) return n; // keep malformed as-is
+        const live = n.signals.filter(s => s.signal_type !== signalType);
+        if (live.length === n.signals.length) return n; // no match — untouched
+        if (live.length === 0) { retracted.push(n.id); return null; } // pure — remove
+        retracted.push(n.id + '(trimmed)'); // mixed — trim signals
+        return { ...n, signals: live };
+      })
+      .filter(Boolean);
+
+    if (retracted.length === 0) return;
+
+    const tmpPath = DAEMON_OUTBOX_JSON + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs.renameSync(tmpPath, DAEMON_OUTBOX_JSON);
+    log(`[BG] Reconcile: retracted ${retracted.length} outbox notification(s) for signalType='${signalType}' (ids: ${retracted.slice(0, 5).join(', ')})`);
+  } catch (e) {
+    log(`[BG] Warning: retractOutboxBySignalType('${signalType}') failed: ${e.message}`);
+  }
+}
+
+/**
+ * TTL-based defense in depth for ambient signal types that have no MCP
+ * source-check counterpart (curiosity_spike from preamble parsing,
+ * hot_symbol_unaddressed_risk, efe_weight_shift, heat). Drops any
+ * ambient_signals.json entry whose detected_at is older than maxAgeMs.
+ *
+ * Called once per cognitive cycle with maxAgeMs = 30 minutes. 30min is
+ * 6× the default 5min tick interval — long enough to avoid prematurely
+ * expiring a signal that is still being refreshed each cycle, short enough
+ * to clear truly stale entries before the 50min MAX_AMBIENT_SIGNALS trim.
+ *
+ * (Amelia Blocker 4 — TASK_1095)
+ *
+ * @param {number} maxAgeMs - Maximum allowed age in milliseconds
+ */
+function reconcileStaleAmbientSignals(maxAgeMs) {
+  try {
+    const existing = readAmbientSignals();
+    if (existing.length === 0) return;
+    const now = Date.now();
+    const fresh = existing.filter(s => {
+      if (!s || !s.detected_at) return true; // keep entries without timestamp (defensive)
+      const ts = Date.parse(s.detected_at);
+      if (!Number.isFinite(ts)) return true; // unparseable → keep
+      return (now - ts) < maxAgeMs;
+    });
+    if (fresh.length !== existing.length) {
+      writeAmbientSignals(fresh);
+      log(`[BG] Reconcile: TTL-dropped ${existing.length - fresh.length} stale ambient signal(s) older than ${Math.round(maxAgeMs / 60000)}min`);
+    }
+  } catch (e) {
+    log(`[BG] Warning: reconcileStaleAmbientSignals failed: ${e.message}`);
+  }
+}
+
+// ── MCP HTTP call (for background use — not Claude sessions) ──────────────────
+function callMcpTool(toolName, toolArgs, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: 'tools/call',
+      params: { name: toolName, arguments: toolArgs || {} },
+    });
+    const url = new URL(MCP_URL);
+    const req = http.request({
+      hostname: url.hostname,
+      port: parseInt(url.port, 10),
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        'Accept': 'application/json, text/event-stream',
+      },
+    }, (res) => {
+      let raw = '';
+      res.on('data', chunk => { raw += chunk; });
+      res.on('end', () => {
+        try {
+          // Handle SSE: extract JSON from "data: {...}" lines
+          if (raw.startsWith('data:') || raw.includes('\ndata:')) {
+            const lines = raw.split('\n').filter(l => l.startsWith('data:'));
+            for (const line of lines) {
+              try {
+                const parsed = JSON.parse(line.slice(5).trim());
+                if (parsed.result || parsed.error) { resolve(parsed); return; }
+              } catch { /* try next line */ }
+            }
+          }
+          resolve(JSON.parse(raw));
+        } catch (e) {
+          reject(new Error(`MCP parse error: ${raw.slice(0, 100)}`));
+        }
+      });
+    });
+    req.setTimeout(timeoutMs, () => req.destroy(new Error('MCP call timeout')));
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+// ── Background cognitive loop helpers ────────────────────────────────────────
+function callDashboardApi(method, routePath, payload, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    const body = payload == null ? null : JSON.stringify(payload);
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: parseInt(KENAZ_HTTP_PORT, 10),
+      path: routePath,
+      method,
+      headers: body
+        ? {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        }
+        : {},
+    }, (res) => {
+      let raw = '';
+      res.on('data', chunk => { raw += chunk; });
+      res.on('end', () => {
+        if ((res.statusCode || 500) >= 400) {
+          reject(new Error(`Dashboard ${method} ${routePath} failed (${res.statusCode}): ${raw.slice(0, 200)}`));
+          return;
+        }
+        try {
+          resolve(raw ? JSON.parse(raw) : {});
+        } catch {
+          resolve({ raw });
+        }
+      });
+    });
+    req.setTimeout(timeoutMs, () => req.destroy(new Error(`Dashboard ${method} ${routePath} timeout`)));
+    req.on('error', reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+function extractMcpText(response) {
+  const content = response?.result?.content || response?.content || [];
+  return (Array.isArray(content) ? content : [content])
+    .map(c => (typeof c === 'string' ? c : c?.text || ''))
+    .join('\n');
+}
+
+function parseJsonSafe(text, fallback = null) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return fallback;
+  }
+}
+
+// ── Graded action routing ────────────────────────────────────────────────────
+/**
+ * Route signals based on max aggregated weight from AttentionBuffer.
+ * Thresholds:
+ *   < 0.3  → noop
+ *   0.3–0.5 → ambient_signals only
+ *   0.5–0.7 → write huginn_attention.json
+ *   0.7–0.9 → daemon_outbox
+ *   > 0.9  → outbox + notify
+ * @param {Array} signalsToAppend - signals collected this cycle
+ * @param {number} maxWeight - highest aggregated weight in buffer
+ */
+function routeByGrade(signalsToAppend, maxWeight) {
+  if (maxWeight < 0.3) {
+    log(`[BG] Graded routing: noop (maxWeight=${maxWeight.toFixed(3)})`);
+    return;
+  }
+
+  // Grade 1: 0.3–0.5 → ambient_signals.json
+  if (maxWeight < 0.5) {
+    log(`[BG] Graded routing: ambient_signals (maxWeight=${maxWeight.toFixed(3)})`);
+    const merged = signalsToAppend.reduce(
+      (acc, signal) => dedupeAndMergeAmbientSignal(acc, signal),
+      readAmbientSignals()
+    );
+    writeAmbientSignals(merged);
+    log(`[BG] Wrote ${signalsToAppend.length} signal(s) to ambient_signals.json`);
+    return;
+  }
+
+  // Grade 2: 0.5–0.7 → write huginn_attention.json (trigger Huginn attention)
+  if (maxWeight < 0.7) {
+    log(`[BG] Graded routing: huginn_attention (maxWeight=${maxWeight.toFixed(3)})`);
+    writeHuginnAttention(signalsToAppend, maxWeight);
+    return;
+  }
+
+  // Grade 3: 0.7–0.9 → daemon_outbox (queue for Ansuz daemon processing)
+  if (maxWeight < 0.9) {
+    log(`[BG] Graded routing: daemon_outbox (maxWeight=${maxWeight.toFixed(3)})`);
+    writeDaemonOutbox(signalsToAppend, maxWeight);
+    return;
+  }
+
+  // Grade 4: >= 0.9 → outbox + notify (urgent)
+  // TASK_1240 fix: decouple routed_weight from constant maxWeight.
+  // Scale by EFE so attenuated signals (EFE 1.10→0.39) don't keep alerting
+  // at routed_weight=1.0 indefinitely. urgent tag preserved for downstream.
+  const efeSnap = attentionBuffer.getEfeSnapshot();
+  const efeValue = efeSnap?.value ?? 1.0; // default 1.0 if no EFE captured
+  const scaledWeight = Math.min(maxWeight, maxWeight * Math.min(efeValue, 1.0));
+  log(`[BG] Graded routing: outbox+notify (maxWeight=${maxWeight.toFixed(3)}, efe=${efeValue.toFixed(3)}, scaledWeight=${scaledWeight.toFixed(3)})`);
+  writeDaemonOutbox(signalsToAppend, maxWeight);
+  // Also write to ambient for visibility
+  const merged = signalsToAppend
+    .map(s => ({
+      ...s,
+      urgent: efeValue >= 0.6, // only truly urgent when EFE is still high
+      routed_weight: scaledWeight,
+    }))
+    .reduce(
+      (acc, signal) => dedupeAndMergeAmbientSignal(acc, signal),
+      readAmbientSignals()
+    );
+  writeAmbientSignals(merged);
+  // Notify via inbox so Ansuz picks it up on next poll
+  try {
+    const inboxData = fs.existsSync(INBOX_JSON)
+      ? JSON.parse(fs.readFileSync(INBOX_JSON, 'utf8'))
+      : { messages: [], processed_ids: [] };
+    inboxData.messages.push({
+      id: `notify_${Date.now()}`,
+      content: `[URGENT SIGNAL] Max attention weight ${maxWeight.toFixed(3)} exceeded 0.9 threshold. Top signals: ${signalsToAppend.slice(0, 3).map(s => s.summary).join('; ')}`,
+      source: 'cognitive_loop',
+      created_at: new Date().toISOString(),
+    });
+    fs.writeFileSync(INBOX_JSON, JSON.stringify(inboxData, null, 2));
+    log(`[BG] Urgent notification written to inbox`);
+  } catch (e) {
+    log(`[BG] Warning: failed to write urgent notification: ${e.message}`);
+  }
+}
+
+function writeHuginnAttention(signals, maxWeight) {
+  try {
+    const themes = signals.slice(0, 5).map(s => ({
+      topic: s.summary,
+      evidence: s.symbols ? s.symbols.join(', ') : '',
+      source: s.source,
+      relevance_score: maxWeight,
+    }));
+    const data = {
+      generated_at: new Date().toISOString(),
+      generated_by: 'cognitive_loop_graded_routing',
+      max_weight: maxWeight,
+      themes,
+    };
+    fs.mkdirSync(path.dirname(HUGINN_ATTENTION_JSON), { recursive: true });
+    fs.writeFileSync(HUGINN_ATTENTION_JSON, JSON.stringify(data, null, 2));
+    log(`[BG] Wrote ${themes.length} theme(s) to huginn-attention.json`);
+  } catch (e) {
+    log(`[BG] Warning: failed to write huginn-attention.json: ${e.message}`);
+  }
+}
+
+function writeDaemonOutbox(signals, maxWeight) {
+  try {
+    const now = new Date();
+    const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+    // Read existing notifications
+    let notifications = [];
+    if (fs.existsSync(DAEMON_OUTBOX_JSON)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(DAEMON_OUTBOX_JSON, 'utf8'));
+        if (Array.isArray(data.notifications)) {
+          notifications = data.notifications;
+        } else if (Array.isArray(data.entries)) {
+          // Migrate legacy entries → notifications format
+          notifications = data.entries.map((e, i) => ({
+            id: `notif_legacy_${i}`,
+            created_at: e.queued_at || now.toISOString(),
+            ttl_hours: 24,
+            consumed_by: [],
+            type: 'cognitive_signal',
+            max_weight: e.max_weight,
+            signals: e.signals || [],
+          }));
+        }
+      } catch { /* ignore corrupt file */ }
+    }
+
+    // 24h TTL cleanup — remove expired notifications
+    notifications = notifications.filter(n => {
+      const created = new Date(n.created_at).getTime();
+      return (now.getTime() - created) < TTL_MS;
+    });
+
+    // Content-dedup: skip append when an unconsumed, unexpired notification with
+    // identical signal summaries already exists. Dedup key = sorted signal summaries.
+    // Prevents 5-min daemon cycle from writing N identical notifications (observed 2026-07-10).
+    const newSummaryKey = signals.slice(0, 10)
+      .map(s => s.summary || s.signal_type || 'unknown')
+      .sort()
+      .join('|');
+    const isDuplicate = notifications.some(n => {
+      const existingSummaryKey = Array.isArray(n.signals)
+        ? n.signals.map(s => s.summary || s.signal_type || 'unknown').sort().join('|')
+        : '';
+      return existingSummaryKey === newSummaryKey;
+    });
+
+    if (isDuplicate) {
+      log('[BG] daemon_outbox: skipped duplicate notification (signals already queued)');
+      return;
+    }
+
+    // Append new notification
+    notifications.push({
+      id: `notif_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      created_at: now.toISOString(),
+      ttl_hours: 24,
+      consumed_by: [],
+      type: 'cognitive_signal',
+      max_weight: maxWeight,
+      signals: signals.slice(0, 10),
+    });
+
+    // Keep last 20 notifications
+    const trimmed = notifications.slice(-20);
+    const outData = { version: 1, notifications: trimmed };
+
+    // Atomic write: write .tmp then rename
+    fs.mkdirSync(path.dirname(DAEMON_OUTBOX_JSON), { recursive: true });
+    const tmpPath = DAEMON_OUTBOX_JSON + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(outData, null, 2));
+    fs.renameSync(tmpPath, DAEMON_OUTBOX_JSON);
+    log(`[BG] Wrote ${signals.length} signal(s) to daemon_outbox.json (${trimmed.length} total notifications)`);
+  } catch (e) {
+    log(`[BG] Warning: failed to write daemon_outbox.json: ${e.message}`);
+  }
+}
+
+// ── Background cognitive loop ─────────────────────────────────────────────────
+let cycleRunning = false;
+
+async function runBackgroundCognitiveLoop(lastActivityMs = Date.now()) {
+  if (cycleRunning) {
+    log('[BG] Skipping cycle — previous cycle still running');
+    return;
+  }
+  cycleRunning = true;
+  log('[BG] Background cognitive loop running...');
+  try {
+    const signalsToAppend = [];
+
+    // Step 4c: hippocampus_due_episodes as signal source (TASK_965)
+    try {
+      const dueResp = await callMcpTool('hippocampus_due_episodes', { projectPath: ROOT }, MCP_FAST_TIMEOUT_MS);
+      const dueContent = dueResp?.result?.content || dueResp?.content || [];
+      const dueText = (Array.isArray(dueContent) ? dueContent : [dueContent])
+        .map(c => (typeof c === 'string' ? c : c?.text || '')).join('\n');
+      let dueCount = 0;
+      try {
+        const parsed = JSON.parse(dueText);
+        dueCount = parsed?.due_count ?? (Array.isArray(parsed?.episodes) ? parsed.episodes.length : 0);
+      } catch { /* non-JSON */ }
+      if (dueCount > 0) {
+        signalsToAppend.push({
+          detected_at: new Date().toISOString(),
+          source: 'hippocampus',
+          signal_type: 'due_episodes',
+          summary: `${dueCount} hippocampus episode(s) due for review`,
+          symbols: ['hippocampus_review'],
+          meta: { due_count: dueCount },
+        });
+        log(`[BG] Signal: due_episodes — ${dueCount} episode(s) due`);
+      } else {
+        // TASK_1095 (I1): source cleared — drop stale ambient entries AND
+        // evict hippocampus_review from attentionBuffer so Grade 4 routing
+        // stops re-appending on subsequent cycles.
+        reconcileSignalSource('due_episodes', false, ['hippocampus_review']);
+      }
+    } catch (e) {
+      log(`[BG] Warning: hippocampus_due_episodes failed (5s timeout): ${e.message}`);
+    }
+
+    // TASK_1095 (Amelia Blocker 4): TTL-based defense in depth for signal types
+    // with no MCP source-check (curiosity_spike, hot_symbol_unaddressed_risk,
+    // efe_weight_shift, heat). 30min > 5min tick interval but < 50min trim horizon.
+    reconcileStaleAmbientSignals(30 * 60 * 1000);
+
+    // Step 5: Feed signals into AttentionBuffer
+    attentionBuffer._decayAll();
+
+    // Feed detected ambient signals into buffer
+    for (const sig of signalsToAppend) {
+      const w = sig.signal_type === 'due_episodes' ? 0.8
+        : sig.signal_type === 'pending_proposals' ? 0.6
+        : 1.0;
+      for (const sym of (sig.symbols || [])) {
+        attentionBuffer.addSignal(sym, w, sig.signal_type);
+      }
+    }
+
+    // Persist attention buffer
+    attentionBuffer.persist();
+    const topSignals = attentionBuffer.getTopSignals(5);
+    const maxWeight = topSignals.length > 0 ? topSignals[0].weight : 0;
+    log(`[BG] AttentionBuffer: ${attentionBuffer.signals.size} symbols, maxWeight: ${maxWeight.toFixed(3)}, top: ${topSignals.map(s => `${s.symbol}(${s.weight.toFixed(2)})`).join(', ') || 'none'}`);
+
+    if (signalsToAppend.length === 0) {
+      log('[BG] No ambient signals this cycle');
+      return;
+    }
+
+    // Step 7: Graded action routing based on max aggregated weight (TASK_965)
+    routeByGrade(signalsToAppend, maxWeight);
+
+  } catch (e) {
+    log(`[BG] Warning: cognitive loop error (non-fatal): ${e.message}`);
+  } finally {
+    cycleRunning = false;
+  }
+}
+
+// ── Inbox helpers ─────────────────────────────────────────────────────────────
+// TASK_1429: ansuz_inbox.json is a typed multi-consumer channel. context-check.js
+// and fatigue-check.js own type='task_completed'. The runner only owns user/thalamus
+// messages (or legacy entries with no type). Filtering here prevents poison-message
+// restart loops when post-complete.js writes task_completed entries with no content.
+const RUNNER_OWNED_INBOX_TYPES = new Set(['user', 'thalamus']);
+
+function readInbox(filePath) {
+  try {
+    const path = filePath || INBOX_JSON;
+    if (!fs.existsSync(path)) return [];
+    const data = JSON.parse(fs.readFileSync(path, 'utf8'));
+    const processed = new Set(data.processed_ids || []);
+    return (data.messages || []).filter(m =>
+      !processed.has(m.id) &&
+      (!m.type || RUNNER_OWNED_INBOX_TYPES.has(m.type))
+    );
+  } catch { return []; }
+}
+
+/**
+ * TASK_908: Check if an inbox message originated from Thalamus autonomous fire.
+ * These messages have source="thalamus" and fire_context with fired symbols.
+ */
+function isThalamusMessage(msg) {
+  return msg && msg.source === 'thalamus';
+}
+
+/**
+ * TASK_908: Build a Level 1-restricted prompt for Thalamus-originated messages.
+ * Level 1 actions: stale rune update, lint fix, inscribe.
+ * No task creation, no architecture changes, no code refactoring.
+ */
+function buildThalamusPrompt(msg) {
+  const ctx = msg.fire_context || {};
+  const symbols = (ctx.fired_symbols || []).map(s => s.symbolId).join(', ');
+  return [
+    `[THALAMUS AUTONOMOUS WAKE — Level 1 Actions Only]`,
+    ``,
+    `The Thalamus pulse network detected ${ctx.fire_count || 'multiple'} symbol(s) firing in a ${ctx.window_secs || 300}s window.`,
+    `Fired symbols: ${symbols || 'unknown'}`,
+    `Commit: ${ctx.commit_sha || 'unknown'}`,
+    `Suggested action: ${ctx.suggested_action || 'update stale runes'}`,
+    ``,
+    `## Allowed Actions (Level 1 only)`,
+    `- Update stale runes for fired symbols (synapse_recall → synapse_inscribe if outdated)`,
+    `- Fix lint issues in fired symbol files`,
+    `- Inscribe new risk/fix runes for discovered issues`,
+    ``,
+    `## Forbidden Actions`,
+    `- Do NOT create new tasks`,
+    `- Do NOT refactor or restructure code`,
+    `- Do NOT modify architecture`,
+    `- Do NOT create pull requests`,
+    `- Do NOT modify files outside the fired symbols' scope`,
+    ``,
+    `Review fired symbols, update any stale runes, and report findings. Keep it brief.`,
+  ].join('\n');
+}
+
+function markProcessed(id, filePath) {
+  try {
+    const path = filePath || INBOX_JSON;
+    const data = fs.existsSync(path)
+      ? JSON.parse(fs.readFileSync(path, 'utf8'))
+      : { messages: [], processed_ids: [] };
+    if (!data.processed_ids) data.processed_ids = [];
+    if (!data.processed_ids.includes(id)) {
+      data.processed_ids.push(id);
+    }
+    fs.writeFileSync(path, JSON.stringify(data, null, 2));
+  } catch { /* ignore */ }
+}
+
+// ── Query helper ──────────────────────────────────────────────────────────────
+function readDaemonModel() {
+  try {
+    const raw = fs.readFileSync(path.join(ROOT, '.kenaz', 'dashboard-models.json'), 'utf8');
+    const models = JSON.parse(raw);
+    return models.daemonModel || 'claude-haiku-4-5';
+  } catch { return 'claude-haiku-4-5'; }
+}
+
+async function runQuery(prompt, sessionId) {
+  const options = {
+    cwd: ROOT,
+    model: readDaemonModel(),
+    allowedTools: [
+      'Bash', 'Edit', 'Glob', 'Grep', 'Read', 'Write',
+      'ToolSearch', 'TodoWrite', 'WebFetch', 'WebSearch',
+      'AskUserQuestion',
+      'mcp__kenaz-dashboard__synapse_recall',
+      'mcp__kenaz-dashboard__kenaz_lsp_callers',
+      'mcp__kenaz-dashboard__kenaz_lsp_references',
+      'mcp__kenaz-dashboard__kenaz_lsp_definition',
+      'mcp__kenaz-dashboard__kenaz_lsp_symbols',
+      'mcp__kenaz-dashboard__synapse_inscribe',
+      'mcp__kenaz-dashboard__synapse_forge',
+      'mcp__kenaz-dashboard__synapse_sigils',
+      'mcp__kenaz-dashboard__hippocampus_episode_start',
+      'mcp__kenaz-dashboard__hippocampus_episode_append',
+      'mcp__kenaz-dashboard__hippocampus_episode_close',
+      'mcp__kenaz-dashboard__hippocampus_episode_recall',
+      'mcp__kenaz-dashboard__hippocampus_episode_link',
+      'mcp__kenaz-dashboard__kenaz_task_create',
+      'mcp__kenaz-dashboard__kenaz_task_update',
+      'mcp__kenaz-dashboard__kenaz_task_list',
+      'mcp__kenaz-dashboard__kenaz_task_get',
+      'mcp__kenaz-dashboard__kenaz_task_delete',
+      'mcp__kenaz-dashboard__cortex_recall',
+    ],
+    mcpServers: {
+      'kenaz-dashboard': {
+        type: 'http',
+        url: MCP_URL,
+      },
+    },
+    permissionMode: 'bypassPermissions',
+    allowDangerouslySkipPermissions: true,
+  };
+
+  if (sessionId) {
+    options.resume = sessionId;
+  }
+
+  let capturedSessionId = sessionId;
+
+  for await (const message of query({ prompt, options })) {
+    // Capture session ID from init event
+    if (message.type === 'system' && message.subtype === 'init') {
+      capturedSessionId = message.session_id;
+      log(`[SDK] Session ID: ${capturedSessionId}`);
+
+      // Write ansuz_session.json so ansuz_daemon can find the JSONL
+      // The JSONL path: ~/.claude/projects/<encoded-cwd>/<session_id>.jsonl
+      const home = process.env.USERPROFILE || process.env.HOME || '';
+      // Claude CLI encodes path: replace : \ / _ with -, strip leading -
+      const encoded = ROOT.replace(/[:\\/_ ]/g, '-').replace(/^-+/, '');
+      const projectsBase = path.join(home, '.claude', 'projects');
+      // Scan for best match (case-insensitive + handle _ vs - difference)
+      let claudeProjectsDir = path.join(projectsBase, encoded);
+      if (!fs.existsSync(claudeProjectsDir)) {
+        try {
+          const dirs = fs.readdirSync(projectsBase);
+          // Try exact case-insensitive first, then underscore→dash normalization
+          const match = dirs.find(d => d.toLowerCase() === encoded.toLowerCase())
+            || dirs.find(d => d.toLowerCase() === encoded.toLowerCase().replace(/_/g, '-'));
+          if (match) claudeProjectsDir = path.join(projectsBase, match);
+        } catch { /* ignore */ }
+      }
+
+      const jsonlPath = path.join(claudeProjectsDir, `${capturedSessionId}.jsonl`);
+      const sessionData = {
+        session_id: capturedSessionId,
+        jsonl_path: jsonlPath,
+        pid: process.pid,
+        started_at: new Date().toISOString(),
+        mode: 'sdk',
+      };
+      fs.mkdirSync(path.dirname(SESSION_JSON), { recursive: true });
+      fs.writeFileSync(SESSION_JSON, JSON.stringify(sessionData, null, 2));
+      log(`[SDK] Session JSON written: ${SESSION_JSON}`);
+    }
+  }
+
+  return capturedSessionId;
+}
+
+// ── Main loop ─────────────────────────────────────────────────────────────────
+async function main() {
+  log(`[Ansuz SDK Runner] Starting — project: ${ROOT}`);
+  log(`[Ansuz SDK Runner] MCP URL: ${MCP_URL}`);
+
+  // Write PID
+  fs.mkdirSync(path.dirname(PID_FILE), { recursive: true });
+  fs.writeFileSync(PID_FILE, String(process.pid));
+
+  // Clear inbox on fresh start
+  fs.writeFileSync(INBOX_JSON, JSON.stringify({ messages: [], processed_ids: [] }, null, 2));
+
+  // Check for existing session (resume mode — like VSCode extension behavior)
+  let existingSessionId = null;
+  if (fs.existsSync(SESSION_JSON)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(SESSION_JSON, 'utf8'));
+      if (existing.session_id) {
+        existingSessionId = existing.session_id;
+        log(`[Session] Found existing session: ${existingSessionId} — will resume`);
+      }
+    } catch { /* ignore */ }
+  }
+
+  let sessionId;
+  if (existingSessionId) {
+    // Resume mode: skip Phase 0, just send a short wake message
+    const resumeMsg = [
+      `You have been resumed by the Kenaz Dashboard.`,
+      `Project: ${ROOT}`,
+      `Resumed at: ${new Date().toISOString()}`,
+      ``,
+      `Review your previous context and continue. If there are pending tasks or observations, address them. Otherwise, summarize your current state and await user input.`,
+    ].join('\n');
+    log(`[Resume] Resuming session ${existingSessionId}...`);
+    try {
+      sessionId = await runQuery(resumeMsg, existingSessionId);
+      clearRestartBlock();
+      log(`[Resume] Complete. Session: ${sessionId}`);
+    } catch (e) {
+      const failure = classifySdkFailure(e);
+      if (failure.shouldBlockRestart) {
+        writeRestartBlock(failure);
+        log(`[Resume] Fatal non-recoverable SDK failure (${failure.reason}); skipping Phase 0 fallback`);
+        process.exit(1);
+      }
+      log(`[Resume] Failed (${e.message}), falling back to Phase 0`);
+      existingSessionId = null; // fall through to Phase 0
+    }
+  }
+
+  if (!existingSessionId) {
+    // Phase 0: full initialization
+    log('[Phase 0] Building Ansuz prompt...');
+    const prompt = await buildWakePrompt();
+    log(`[Phase 0] Prompt built (${prompt.length} chars). Starting session...`);
+
+    try {
+      sessionId = await runQuery(prompt, null);
+      clearRestartBlock();
+      log(`[Phase 0] Complete. Session: ${sessionId}`);
+      // Acknowledge ISBAR handoff now that we have the new sessionId
+      try {
+        const ansuzHandoff = require('./ansuz-handoff');
+        ansuzHandoff.acknowledgeHandoff(ROOT, sessionId);
+      } catch { /* non-blocking */ }
+    } catch (e) {
+      const failure = classifySdkFailure(e);
+      if (failure.shouldBlockRestart) {
+        writeRestartBlock(failure);
+      }
+      log(`[ERROR] Phase 0 failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Multi-turn loop: poll inbox for user messages
+  log('[Multi-turn] Polling ansuz_inbox.json for user messages...');
+  const POLL_INTERVAL_MS = 1000;
+  const MAX_IDLE_MS = 30 * 60 * 1000; // 30 min idle timeout
+  let lastActivityMs = Date.now();
+
+  // Background cognitive loop — independent of inbox polling, non-blocking
+  log(`[BG] Starting background cognitive loop (interval: ${BACKGROUND_LOOP_INTERVAL_MS / 1000}s)`);
+  const bgLoopTimer = setInterval(() => {
+    runBackgroundCognitiveLoop(lastActivityMs).catch(e => log(`[BG] Unhandled error: ${e.message}`));
+  }, BACKGROUND_LOOP_INTERVAL_MS);
+
+  while (true) {
+    await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+
+    // Idle timeout
+    if (Date.now() - lastActivityMs > MAX_IDLE_MS) {
+      log('[Multi-turn] Idle timeout — exiting');
+      break;
+    }
+
+    const pending = readInbox();
+    if (pending.length === 0) continue;
+
+    for (const msg of pending) {
+      // TASK_1429: markProcessed FIRST — prevents watchdog restart-loop bait.
+      // Any unhandled exception below would previously skip markProcessed, causing
+      // the Rust watchdog to restart the runner and re-read the same poison message.
+      markProcessed(msg.id);
+
+      const isThalamus = isThalamusMessage(msg);
+
+      // TASK_1429: Defensive guard — non-thalamus messages must have string content.
+      if (!isThalamus && typeof msg.content !== 'string') {
+        log(`[Multi-turn] Warning: msg ${msg.id} (type=${msg.type}) missing string content — skipped`);
+        continue;
+      }
+
+      const msgLabel = isThalamus ? 'Thalamus autonomous' : 'User';
+      const preview = isThalamus ? '(thalamus fire)' : msg.content.slice(0, 80);
+      log(`[Multi-turn] ${msgLabel} message: ${preview}`);
+      lastActivityMs = Date.now();
+
+      // TASK_908: Use restricted Level 1 prompt for thalamus-originated messages
+      const prompt = isThalamus ? buildThalamusPrompt(msg) : msg.content;
+
+      try {
+        sessionId = await runQuery(prompt, sessionId);
+        clearRestartBlock();
+        log(`[Multi-turn] ${msgLabel} response complete. Session: ${sessionId}`);
+      } catch (e) {
+        const failure = classifySdkFailure(e);
+        if (failure.shouldBlockRestart) {
+          writeRestartBlock(failure);
+        }
+        log(`[ERROR] Turn failed: ${e.message}`);
+      }
+    }
+  }
+
+  // Cleanup
+  clearInterval(bgLoopTimer);
+  try { ansuzState.writeState(ROOT, {}); } catch { /* ignore */ }
+  // NOTE: PID file intentionally NOT deleted — Rust watchdog in ansuz_daemon/mod.rs
+  // detects dead PID via is_pid_alive() and auto-restarts the runner.
+  // Deleting it would prevent watchdog from knowing a restart is needed.
+  log('[Ansuz SDK Runner] Exiting');
+}
+
+// TASK_1094: only run main() when invoked as a script (not when require()'d by tests).
+// Daemon launch path remains `node ansuz-sdk-runner.js` → require.main === module → main runs.
+if (require.main === module) {
+  main().catch(e => {
+    log(`[FATAL] ${e.message}\n${e.stack}`);
+    try { ansuzState.writeState(ROOT, {}); } catch { /* ignore */ }
+    process.exit(1);
+  });
+}
+
+// ── Exported API contract (TASK_964) ─────────────────────────────────────────
+module.exports = {
+  AttentionBuffer,
+  attentionBuffer,
+  getAggregatedWeight: (symbol) => attentionBuffer.getAggregatedWeight(symbol),
+  getTopSignals: (n) => attentionBuffer.getTopSignals(n),
+  // TASK_1094: exported for tests + downstream tuning
+  REPLACE_WINDOW_MS,
+  ATTENTION_HALFLIFE_MS,
+  ATTENTION_FLOOR,
+  // TASK_1095: exported so tests can exercise the reconcile path without
+  // spinning up the full background cognitive loop.
+  reconcileSignalSource,
+  reconcileStaleAmbientSignals,
+  readAmbientSignals,
+  writeAmbientSignals,
+  // TASK_1429: exported for inbox protocol unit tests
+  readInbox,
+  markProcessed,
+  RUNNER_OWNED_INBOX_TYPES,
+};