kenaz 0.0.0-stage → 0.3.2

package/core/.kenaz/specialist/cognitive-hub-e2e.test.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+/**
+ * TASK_967 — E2E Smoke Test: Global Cognitive Hub Pipeline
+ *
+ * Validates the full pipeline:
+ *   1. AttentionBuffer: decay + aggregation after cognitive loop
+ *   2. Graded routing: correct actions at each threshold level
+ *   3. daemon_outbox.json: write + consumed_by update after hook read
+ *   4. Hook injection: latency < 100ms
+ *
+ * Usage: node .kenaz/specialist/cognitive-hub-e2e.test.js [--project-path=...]
+ * Exit code: 0 = all pass, 1 = failures
+ */
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { execFileSync } = require('child_process');
+
+// ── Config ───────────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const projectPath = (() => {
+  const flag = args.find(a => a.startsWith('--project-path='));
+  return flag ? flag.split('=').slice(1).join('=') : path.resolve(__dirname, '../..');
+})();
+
+const SPECIALIST_DIR   = path.join(projectPath, '.kenaz', 'specialist');
+const ATTENTION_PATH   = path.join(SPECIALIST_DIR, 'attention_buffer.json');
+const OUTBOX_PATH      = path.join(SPECIALIST_DIR, 'daemon_outbox.json');
+const HOOK_SCRIPT      = path.join(projectPath, '.claude', 'hooks', 'daemon-outbox-hook.js');
+
+const ATTENTION_HALFLIFE_MS = 12 * 60 * 60 * 1000;
+const ATTENTION_FLOOR = 0.01;
+
+let passed = 0;
+let failed = 0;
+const results = [];
+
+function assert(name, condition, evidence) {
+  if (condition) {
+    passed++;
+    results.push({ name, status: 'PASS', evidence });
+    console.log(`  ✓ ${name}`);
+  } else {
+    failed++;
+    results.push({ name, status: 'FAIL', evidence });
+    console.error(`  ✗ ${name} — ${evidence}`);
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function decay(w, dtMs) {
+  if (dtMs <= 0) return w;
+  return w * Math.pow(2, -dtMs / ATTENTION_HALFLIFE_MS);
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+// ── Backup & Restore ─────────────────────────────────────────────────────────
+const backups = new Map();
+
+function backup(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      backups.set(filePath, fs.readFileSync(filePath, 'utf8'));
+    } else {
+      backups.set(filePath, null);
+    }
+  } catch { backups.set(filePath, null); }
+}
+
+function restore(filePath) {
+  const content = backups.get(filePath);
+  if (content === null || content === undefined) {
+    try { fs.unlinkSync(filePath); } catch { /* ok */ }
+  } else {
+    fs.writeFileSync(filePath, content);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// TEST SUITE 1: AttentionBuffer — decay + aggregation
+// ══════════════════════════════════════════════════════════════════════════════
+function testAttentionBufferDecayAndAggregation() {
+  console.log('\n── Test Suite 1: AttentionBuffer decay & aggregation ──');
+
+  backup(ATTENTION_PATH);
+
+  try {
+    // 1a. Write a buffer with signals at known timestamps
+    const now = Date.now();
+    const sixHoursAgo = now - (6 * 60 * 60 * 1000); // half of halflife
+    const twentyFourHoursAgo = now - (24 * 60 * 60 * 1000); // 2 halflives
+
+    const testBuffer = {
+      version: 1,
+      updated_at: new Date(now).toISOString(),
+      prevEfeSnapshot: { value: 0.42, captured_at: new Date(now).toISOString() },
+      signals: [
+        { symbol: 'hotSymbol_A', weight: 2.0, lastUpdated: sixHoursAgo, source: 'heat', meta: { raw_id: 'sym_test_A' } },
+        { symbol: 'hotSymbol_B', weight: 1.0, lastUpdated: twentyFourHoursAgo, source: 'curiosity' },
+        { symbol: 'tinySignal_C', weight: 0.005, lastUpdated: sixHoursAgo, source: 'risk' }, // below floor after decay
+      ],
+    };
+    writeJson(ATTENTION_PATH, testBuffer);
+
+    // 1b. Verify file written correctly
+    const loaded = readJson(ATTENTION_PATH);
+    assert('attention_buffer.json written with version field',
+      loaded.version === 1, `version=${loaded.version}`);
+    assert('attention_buffer.json has 3 signals',
+      loaded.signals.length === 3, `signals.length=${loaded.signals.length}`);
+    assert('prevEfeSnapshot persisted',
+      loaded.prevEfeSnapshot && loaded.prevEfeSnapshot.value === 0.42,
+      `prevEfeSnapshot.value=${loaded.prevEfeSnapshot?.value}`);
+
+    // 1c. Verify decay math
+    const decayedA = decay(2.0, now - sixHoursAgo);
+    assert('6h decay: weight ~1.414 (half-life=12h)',
+      Math.abs(decayedA - Math.SQRT2) < 0.01,
+      `expected ~${Math.SQRT2.toFixed(4)}, got ${decayedA.toFixed(4)}`);
+
+    const decayedB = decay(1.0, now - twentyFourHoursAgo);
+    assert('24h decay: weight ~0.25 (2 half-lives)',
+      Math.abs(decayedB - 0.25) < 0.01,
+      `expected ~0.25, got ${decayedB.toFixed(4)}`);
+
+    // 1d. Verify floor eviction
+    const decayedC = decay(0.005, now - sixHoursAgo);
+    assert('tiny signal decays below ATTENTION_FLOOR',
+      decayedC < ATTENTION_FLOOR,
+      `decayed=${decayedC.toFixed(6)}, floor=${ATTENTION_FLOOR}`);
+
+    // 1e. Aggregation: addSignal merges DIFFERENT sources via decay+add (cross-source compounding)
+    // Simulate: existing decayed weight + new weight from a DIFFERENT source within window
+    const existingDecayed = decay(2.0, 1000); // 1 second ago
+    const aggregated = existingDecayed + 0.5;
+    assert('cross-source aggregation: decayed_existing + new_weight',
+      aggregated > 2.0 && aggregated < 2.5 + 0.001,
+      `aggregated=${aggregated.toFixed(4)}`);
+
+    // 1f. TASK_1094: replace-if-recent — addSignal called twice with same source
+    //      within REPLACE_WINDOW_MS REPLACES weight, does not compound.
+    //      Cross-source within window still compounds.
+    // Use a clean buffer file so the singleton in the required module loads empty state.
+    writeJson(ATTENTION_PATH, { version: 1, signals: [] });
+    delete require.cache[require.resolve(
+      path.join(projectPath, '.specialist', 'Ansuz', 'tools', 'ansuz-sdk-runner.js'))];
+    const { AttentionBuffer, REPLACE_WINDOW_MS } = require(
+      path.join(projectPath, '.specialist', 'Ansuz', 'tools', 'ansuz-sdk-runner.js'));
+
+    assert('REPLACE_WINDOW_MS exported and = 10 minutes',
+      REPLACE_WINDOW_MS === 10 * 60 * 1000,
+      `REPLACE_WINDOW_MS=${REPLACE_WINDOW_MS}`);
+
+    // Same-source replace-if-recent: addSignal called twice with same source
+    const buf1 = new AttentionBuffer();
+    buf1.addSignal('test_sym_replace', 0.6, 'pending_proposals');
+    buf1.addSignal('test_sym_replace', 0.6, 'pending_proposals');
+    const replaceEntry = buf1.signals.get('test_sym_replace');
+    assert('addSignal called twice with same source within window: weight ≈ 0.6 (replaced, not summed)',
+      Math.abs(replaceEntry.weight - 0.6) < 0.001,
+      `weight=${replaceEntry.weight.toFixed(4)} (expected ~0.6, NOT 1.2)`);
+
+    // Cross-source compounding still works within window
+    const buf2 = new AttentionBuffer();
+    buf2.addSignal('test_sym_compound', 0.6, 'pending_proposals');
+    buf2.addSignal('test_sym_compound', 0.6, 'heat');
+    const compoundEntry = buf2.signals.get('test_sym_compound');
+    assert('addSignal with DIFFERENT source within window: weight ≈ 1.2 (cross-source compounds)',
+      compoundEntry.weight > 1.19 && compoundEntry.weight < 1.21,
+      `weight=${compoundEntry.weight.toFixed(4)} (expected ~1.2)`);
+
+    // Same-source after window simulated by manually back-dating lastUpdated
+    const buf3 = new AttentionBuffer();
+    buf3.addSignal('test_sym_aged', 0.6, 'pending_proposals');
+    const aged = buf3.signals.get('test_sym_aged');
+    aged.lastUpdated = Date.now() - (REPLACE_WINDOW_MS + 1000); // outside window
+    buf3.addSignal('test_sym_aged', 0.6, 'pending_proposals');
+    const agedEntry = buf3.signals.get('test_sym_aged');
+    assert('addSignal same source AFTER window: decay+add (not replace)',
+      agedEntry.weight > 1.19 && agedEntry.weight < 1.21, // 0.6 decayed ~10min ≈ 0.6 + 0.6 ≈ 1.2
+      `weight=${agedEntry.weight.toFixed(4)} (expected ~1.2 after window)`);
+
+  } finally {
+    restore(ATTENTION_PATH);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// TEST SUITE 2: Graded routing thresholds
+// ══════════════════════════════════════════════════════════════════════════════
+function testGradedRoutingThresholds() {
+  console.log('\n── Test Suite 2: Graded routing thresholds ──');
+
+  // Test the threshold boundaries defined in routeByGrade():
+  //   < 0.3  → noop
+  //   0.3–0.5 → ambient_signals only
+  //   0.5–0.7 → huginn_attention.json
+  //   0.7–0.9 → daemon_outbox
+  //   >= 0.9  → outbox + notify (ambient + inbox)
+
+  const thresholds = [
+    { weight: 0.0,  expected: 'noop',            desc: 'weight=0.0 → noop' },
+    { weight: 0.29, expected: 'noop',            desc: 'weight=0.29 → noop (below 0.3)' },
+    { weight: 0.3,  expected: 'ambient_signals', desc: 'weight=0.3 → ambient_signals (boundary)' },
+    { weight: 0.45, expected: 'ambient_signals', desc: 'weight=0.45 → ambient_signals' },
+    { weight: 0.5,  expected: 'huginn_attention', desc: 'weight=0.5 → huginn_attention (boundary)' },
+    { weight: 0.65, expected: 'huginn_attention', desc: 'weight=0.65 → huginn_attention' },
+    { weight: 0.7,  expected: 'daemon_outbox',   desc: 'weight=0.7 → daemon_outbox (boundary)' },
+    { weight: 0.85, expected: 'daemon_outbox',   desc: 'weight=0.85 → daemon_outbox' },
+    { weight: 0.9,  expected: 'outbox_notify',   desc: 'weight=0.9 → outbox+notify (boundary)' },
+    { weight: 1.0,  expected: 'outbox_notify',   desc: 'weight=1.0 → outbox+notify' },
+  ];
+
+  for (const t of thresholds) {
+    let actual;
+    if (t.weight < 0.3) actual = 'noop';
+    else if (t.weight < 0.5) actual = 'ambient_signals';
+    else if (t.weight < 0.7) actual = 'huginn_attention';
+    else if (t.weight < 0.9) actual = 'daemon_outbox';
+    else actual = 'outbox_notify';
+
+    assert(t.desc, actual === t.expected, `actual=${actual}`);
+  }
+
+  // Verify the source code matches these thresholds
+  const runnerSrc = fs.readFileSync(
+    path.join(projectPath, '.specialist', 'Ansuz', 'tools', 'ansuz-sdk-runner.js'), 'utf8');
+
+  assert('routeByGrade: noop threshold < 0.3 in source',
+    runnerSrc.includes('maxWeight < 0.3'),
+    'checking source for maxWeight < 0.3');
+  assert('routeByGrade: ambient threshold < 0.5 in source',
+    runnerSrc.includes('maxWeight < 0.5'),
+    'checking source for maxWeight < 0.5');
+  assert('routeByGrade: huginn threshold < 0.7 in source',
+    runnerSrc.includes('maxWeight < 0.7'),
+    'checking source for maxWeight < 0.7');
+  assert('routeByGrade: daemon_outbox threshold < 0.9 in source',
+    runnerSrc.includes('maxWeight < 0.9'),
+    'checking source for maxWeight < 0.9');
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// TEST SUITE 3: daemon_outbox.json write + consumed_by update
+// ══════════════════════════════════════════════════════════════════════════════
+function testDaemonOutboxWriteAndConsume() {
+  console.log('\n── Test Suite 3: daemon_outbox.json write + consumed_by ──');
+
+  backup(OUTBOX_PATH);
+
+  try {
+    // 3a. Write a daemon_outbox with a notification
+    const notifId = `notif_test_${Date.now()}`;
+    const outboxData = {
+      version: 1,
+      notifications: [
+        {
+          id: notifId,
+          created_at: new Date().toISOString(),
+          ttl_hours: 24,
+          consumed_by: [],
+          type: 'cognitive_signal',
+          max_weight: 0.75,
+          signals: [
+            { summary: 'Test signal for E2E validation', signal_type: 'hot_symbol_unaddressed_risk', symbols: ['testSym'] },
+          ],
+        },
+      ],
+    };
+    writeJson(OUTBOX_PATH, outboxData);
+
+    // 3b. Verify outbox written
+    const loaded = readJson(OUTBOX_PATH);
+    assert('daemon_outbox.json written with version=1',
+      loaded.version === 1, `version=${loaded.version}`);
+    assert('daemon_outbox has 1 notification',
+      loaded.notifications.length === 1, `count=${loaded.notifications.length}`);
+    assert('notification has empty consumed_by initially',
+      Array.isArray(loaded.notifications[0].consumed_by) && loaded.notifications[0].consumed_by.length === 0,
+      `consumed_by=${JSON.stringify(loaded.notifications[0].consumed_by)}`);
+    assert('notification has correct structure (id, created_at, ttl_hours, type, max_weight, signals)',
+      loaded.notifications[0].id === notifId &&
+      loaded.notifications[0].ttl_hours === 24 &&
+      loaded.notifications[0].type === 'cognitive_signal' &&
+      loaded.notifications[0].max_weight === 0.75 &&
+      Array.isArray(loaded.notifications[0].signals),
+      'all fields present and correct');
+
+    // 3c. Simulate hook consumption (daemon-outbox-hook.js logic)
+    const testSessionId = 'test_session_e2e_967';
+    // Read, filter pending, mark consumed
+    const hookData = readJson(OUTBOX_PATH);
+    const pending = hookData.notifications.filter(n => {
+      if (!n || !n.id) return false;
+      if (Array.isArray(n.consumed_by) && n.consumed_by.includes(testSessionId)) return false;
+      const created = new Date(n.created_at).getTime();
+      if (isNaN(created) || (Date.now() - created) >= 24 * 60 * 60 * 1000) return false;
+      return true;
+    });
+
+    assert('hook finds 1 pending notification',
+      pending.length === 1, `pending=${pending.length}`);
+
+    // Mark consumed_by
+    const match = hookData.notifications.find(n => n.id === notifId);
+    if (match) {
+      if (!Array.isArray(match.consumed_by)) match.consumed_by = [];
+      match.consumed_by.push(testSessionId);
+    }
+    writeJson(OUTBOX_PATH, hookData);
+
+    // 3d. Verify consumed_by updated
+    const afterConsume = readJson(OUTBOX_PATH);
+    const consumedNotif = afterConsume.notifications.find(n => n.id === notifId);
+    assert('consumed_by updated after hook read',
+      consumedNotif && consumedNotif.consumed_by.includes(testSessionId),
+      `consumed_by=${JSON.stringify(consumedNotif?.consumed_by)}`);
+
+    // 3e. Verify same session won't see it again
+    const pendingAfter = afterConsume.notifications.filter(n => {
+      if (Array.isArray(n.consumed_by) && n.consumed_by.includes(testSessionId)) return false;
+      return true;
+    });
+    assert('consumed notification not visible to same session',
+      pendingAfter.length === 0, `pending_after=${pendingAfter.length}`);
+
+    // 3f. Verify different session still sees it
+    const otherSessionPending = afterConsume.notifications.filter(n => {
+      if (Array.isArray(n.consumed_by) && n.consumed_by.includes('other_session')) return false;
+      return true;
+    });
+    assert('notification still visible to different session',
+      otherSessionPending.length === 1, `other_pending=${otherSessionPending.length}`);
+
+    // 3g. TTL expiry test
+    const expiredOutbox = {
+      version: 1,
+      notifications: [
+        {
+          id: 'notif_expired',
+          created_at: new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString(), // 25h ago
+          ttl_hours: 24,
+          consumed_by: [],
+          type: 'cognitive_signal',
+          max_weight: 0.8,
+          signals: [],
+        },
+      ],
+    };
+    writeJson(OUTBOX_PATH, expiredOutbox);
+
+    const expiredData = readJson(OUTBOX_PATH);
+    const expiredPending = expiredData.notifications.filter(n => {
+      const created = new Date(n.created_at).getTime();
+      return !isNaN(created) && (Date.now() - created) < 24 * 60 * 60 * 1000;
+    });
+    assert('expired notification (25h) filtered out by TTL',
+      expiredPending.length === 0, `expired_pending=${expiredPending.length}`);
+
+  } finally {
+    restore(OUTBOX_PATH);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// TEST SUITE 4: Hook injection latency
+// ══════════════════════════════════════════════════════════════════════════════
+function testHookInjectionLatency() {
+  console.log('\n── Test Suite 4: Hook injection latency ──');
+
+  backup(OUTBOX_PATH);
+
+  try {
+    // 4a. Test with empty outbox (fast path)
+    writeJson(OUTBOX_PATH, { version: 1, notifications: [] });
+
+    const emptyStart = process.hrtime.bigint();
+    try {
+      execFileSync(process.execPath, [HOOK_SCRIPT], {
+        timeout: 5000,
+        env: { ...process.env, CLAUDE_PROJECT_DIR: projectPath, CLAUDE_SESSION_ID: 'latency_test' },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch { /* exit code non-zero is ok for empty */ }
+    const emptyElapsed = Number(process.hrtime.bigint() - emptyStart) / 1e6;
+    assert(`hook latency with empty outbox: ${emptyElapsed.toFixed(1)}ms < 100ms`,
+      emptyElapsed < 100, `elapsed=${emptyElapsed.toFixed(1)}ms`);
+
+    // 4b. Test with populated outbox (3 notifications)
+    const populatedOutbox = {
+      version: 1,
+      notifications: Array.from({ length: 3 }, (_, i) => ({
+        id: `notif_latency_${i}`,
+        created_at: new Date().toISOString(),
+        ttl_hours: 24,
+        consumed_by: [],
+        type: 'cognitive_signal',
+        max_weight: 0.75 + i * 0.05,
+        signals: [
+          { summary: `Latency test signal ${i}`, signal_type: 'test', symbols: [`sym${i}`] },
+        ],
+      })),
+    };
+    writeJson(OUTBOX_PATH, populatedOutbox);
+
+    const popStart = process.hrtime.bigint();
+    let hookOutput = '';
+    try {
+      hookOutput = execFileSync(process.execPath, [HOOK_SCRIPT], {
+        timeout: 5000,
+        env: { ...process.env, CLAUDE_PROJECT_DIR: projectPath, CLAUDE_SESSION_ID: 'latency_test_pop' },
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      hookOutput = e.stdout || '';
+    }
+    const popElapsed = Number(process.hrtime.bigint() - popStart) / 1e6;
+    assert(`hook latency with 3 notifications: ${popElapsed.toFixed(1)}ms < 100ms`,
+      popElapsed < 100, `elapsed=${popElapsed.toFixed(1)}ms`);
+
+    // 4c. Verify hook output contains DAEMON_SIGNAL
+    assert('hook output contains [DAEMON_SIGNAL]',
+      hookOutput.includes('[DAEMON_SIGNAL]'),
+      `output=${hookOutput.slice(0, 200)}`);
+
+    // 4d. Verify consumed_by was updated by hook
+    const afterHook = readJson(OUTBOX_PATH);
+    const consumedCount = afterHook.notifications.filter(n =>
+      Array.isArray(n.consumed_by) && n.consumed_by.includes('latency_test_pop')
+    ).length;
+    assert('hook updated consumed_by for processed notifications',
+      consumedCount > 0, `consumed=${consumedCount}`);
+
+    // 4e. Test with missing file (should exit silently, no error)
+    const missingPath = OUTBOX_PATH + '.nonexistent';
+    const missingStart = process.hrtime.bigint();
+    try {
+      execFileSync(process.execPath, [HOOK_SCRIPT], {
+        timeout: 5000,
+        env: { ...process.env, CLAUDE_PROJECT_DIR: projectPath + '_nonexistent', CLAUDE_SESSION_ID: 'missing_test' },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch { /* expected */ }
+    const missingElapsed = Number(process.hrtime.bigint() - missingStart) / 1e6;
+    assert(`hook with missing file: ${missingElapsed.toFixed(1)}ms < 100ms (silent exit)`,
+      missingElapsed < 100, `elapsed=${missingElapsed.toFixed(1)}ms`);
+
+  } finally {
+    restore(OUTBOX_PATH);
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// RUN
+// ══════════════════════════════════════════════════════════════════════════════
+console.log('═══════════════════════════════════════════════════════════');
+console.log(' TASK_967: Global Cognitive Hub Pipeline — E2E Smoke Test');
+console.log('═══════════════════════════════════════════════════════════');
+console.log(`Project: ${projectPath}`);
+console.log(`Time: ${new Date().toISOString()}`);
+
+testAttentionBufferDecayAndAggregation();
+testGradedRoutingThresholds();
+testDaemonOutboxWriteAndConsume();
+testHookInjectionLatency();
+
+console.log('\n═══════════════════════════════════════════════════════════');
+console.log(` Results: ${passed} passed, ${failed} failed, ${passed + failed} total`);
+console.log('═══════════════════════════════════════════════════════════');
+
+// Write results summary for CI / automation
+const summary = {
+  task_id: 'TASK_967',
+  ran_at: new Date().toISOString(),
+  passed,
+  failed,
+  total: passed + failed,
+  results: results.map(r => ({ name: r.name, status: r.status, evidence: r.evidence })),
+};
+const summaryPath = path.join(SPECIALIST_DIR, 'cognitive-hub-e2e-results.json');
+writeJson(summaryPath, summary);
+console.log(`\nResults written to: ${summaryPath}`);
+
+process.exit(failed > 0 ? 1 : 0);

package/core/.kenaz/specialist/daemon-manifest.yaml

@@ -0,0 +1,168 @@
+# Daemon-Managed Paths Manifest
+# Files and directories written by background daemons (Ansuz, Muninn, Thalamus, etc.)
+# during active sessions.
+#
+# This manifest carries THREE SEPARABLE responsibilities (TASK_1818, TASK_1827):
+#   (a) COMMIT EXCLUSION — the path must never be swept into a task commit by
+#       the blanket `git add -A` staging in the worktree flow.
+#   (b) PRE-MERGE REVERT — the path is reverted to HEAD (`git checkout HEAD --`)
+#       before merge operations, because daemon-drift on tracked files would
+#       otherwise block checkout/merge ("local changes would be overwritten").
+#   (c) GC DIRT ALLOWLIST — a dirty copy of the path (tracked-modified OR
+#       untracked) inside an AGENT WORKTREE is daemon/harness noise and does
+#       not block worktree garbage collection (worktree-create.js
+#       gcStaleWorktrees). (c) has ZERO effect on the merge flow.
+#
+# state_files and static_paths entries get (a), (b) AND (c).
+# commit_exclude_files entries get ONLY (a) — they are NEVER reverted, because
+# they hold USER-authored edits whose uncommitted state must survive a
+# post-complete merge. Putting a user-edited config in state_files silently
+# discards the user's settings on every dispatch (TASK_1818 data-loss report:
+# dashboard-models.json model selection reverted after each merge). They are
+# also NOT GC noise: user-authored bytes are never treated as discardable.
+# gc_disposable_paths entries get ONLY (c) — daemon/harness droppings that must
+# NOT gain (a)/(b) semantics (e.g. reverting .claude/settings.json pre-merge
+# would discard the user's permission edits — the exact TASK_1818 failure).
+#
+# To add a new daemon-managed path: add it to the appropriate list below.
+# No code change required — post-complete.js (state_files/static_paths) and
+# post-complete/git-merge.js (commit_exclude_files) read this manifest at
+# runtime. Moving an entry between lists changes behavior only.
+#
+# TASK_2352: dot-path static_paths are also appended to sub-project .gitignore on project
+# open (dashboard project/manager.rs include_str!s this file; a unit test asserts agreement).
+#
+# See: structural audit SECTION D.2 in post-complete.js
+
+# Files written by specialist daemons during active sessions
+state_files:
+  - .kenaz/specialist/turn_context_state.json
+  - .kenaz/specialist/ansuz_rules.yaml
+  - .kenaz/specialist/ansuz_session.json
+  - .kenaz/specialist/ansuz_state.json
+  - .kenaz/specialist/ansuz_inbox.json
+  - .kenaz/specialist/ansuz_predictions.json
+  - .kenaz/specialist/ansuz_skill_matrix.json
+  - .kenaz/specialist/attention_buffer.json
+  - .kenaz/specialist/cognitive_health.json
+  - .kenaz/specialist/daemon_outbox.json
+  - .kenaz/specialist/muninn_observations.json
+  - .kenaz/specialist/ambient_signals.json
+  - .kenaz/huginn-attention.json
+  - .kenaz/specialist/ansuz_ritual_log.jsonl
+  - .kenaz/specialist/ritual_state.json
+  - .kenaz/specialist/turn_feedback.jsonl
+  - .kenaz/specialist/ansuz_motivational_state.json
+  - .kenaz/specialist/ansuz_self_model.json
+  - .kenaz/specialist/cognitive_canary.json
+  - .kenaz/specialist/lessons_pending_index.jsonl
+  - .kenaz/specialist/metacognitive_state.json
+  - .kenaz/specialist/motivational_state.json
+  - .kenaz/specialist/reflex_executor_approved.flag
+  - .kenaz/specialist/sigils_pending.jsonl
+  - .kenaz/specialist/thinking_log.jsonl
+  # Added 2026-05-01 — observed daemon-drift on user branch between sessions
+  - .kenaz/specialist/initiator_state.json
+  # Added 2026-05-03 TASK_1416 — handoff snapshot caused unmerged_index in TASK_1413.
+  # TASK_1829: singular slot retired by M3 (TASK_1760); daemons now write per-session
+  # slots under handoffs/. Kept as belt-and-braces in case an old in-flight writer
+  # resurrects the file. The handoffs/ directory entry lives under static_paths —
+  # state_files is matched with an exact `includes()`, so a trailing-slash entry here
+  # would never match .kenaz/specialist/handoffs/<id>.json (see revert-daemon-state.js
+  # isManagedByManifest: only static_paths gets the endsWith('/') prefix test).
+  - .kenaz/specialist/ansuz_session_handoff.json
+  - .kenaz/specialist/attribution_reports.jsonl
+  - .kenaz/specialist/attribution_summary.json
+  - .kenaz/specialist/reflex_initiator_dryrun.jsonl
+  - .kenaz/transcripts/index.json
+  # NOTE: .kenaz/dashboard-models.json moved to commit_exclude_files (TASK_1818)
+  # — it is USER config (dashboard UI model selection), not daemon state.
+
+# User-editable configuration files — responsibility (a) ONLY.
+# Excluded from task commits, but NEVER reverted to HEAD: these are written by
+# the USER (e.g. via the dashboard UI), not by daemons. Reverting them silently
+# discards the user's uncommitted settings. Read by git-merge.js
+# listCommitExcludeOnlyFiles().
+commit_exclude_files:
+  # Written by dashboard_settings.rs post_models when the user picks dispatch
+  # models in the dashboard UI. Was in state_files until 2026-07-26 (TASK_1818):
+  # every post-complete merge reverted the user's model choice to HEAD.
+  - .kenaz/dashboard-models.json
+  # TASK_2244: per-machine yggdrasil settings (enabled/relay_url/node_name/...).
+  # The tracked .kenaz/yggdrasil.yaml keeps only the shared room key.
+  - .kenaz/yggdrasil.local.yaml
+  - .kenaz/yggdrasil.yaml.premigrate.bak
+
+# GC dirt allowlist — responsibility (c) ONLY (TASK_1827).
+# Dirty copies of these paths inside an agent worktree are daemon/harness
+# droppings and never block worktree GC. They deliberately do NOT get (a)/(b):
+#   - .claude/settings.json is tracked USER config that the harness mutates
+#     (permission auto-adds during agent runs); reverting it pre-merge would
+#     discard the user's uncommitted permission edits (TASK_1818 failure class),
+#   - the others are daemon logs/state whose merge-flow handling is unchanged
+#     by this card.
+# Real agent deliverables (e.g. .formation/TASK_XXXX_HANDOFF.md) must NEVER be
+# listed here — an untracked file NOT on the combined noise list
+# (state_files + static_paths + gc_disposable_paths) is treated as real work
+# and keeps the worktree alive.
+gc_disposable_paths:
+  - .claude/settings.json
+  - .kenaz/channel_heartbeats.jsonl
+  - .synapse/prediction_resolution_log.jsonl
+  - .kenaz/specialist/ansuz_project_pins.json
+  # TASK_1840: local worktree copy of the agent progress note, written AFTER the
+  # final commit per the dispatch prompt -> permanent dirt that blocked GC.
+  # Trailing * = prefix match (worktree-create.js isNoisePath) on entries in
+  # .kenaz/specialist/ ONLY -- the remainder may not contain '/', so this does
+  # NOT loosen the directory itself (dispatch prompts, handoffs, dispatch params
+  # in the same dir stay real state). Additional gate in code: the file is
+  # disposable ONLY when its note is confirmed merged into the core chart
+  # (.specialist/sessions/chart_<TASK>.json progress_notes[]); otherwise it is
+  # real work and keeps the worktree (worktree-create.js isLandedProgressNote).
+  - .kenaz/specialist/progress_note_*
+
+# Files and directories written by formation/synapse infrastructure
+# Entries ending with / are directories (all contents are daemon-managed)
+static_paths:
+  # TASK_1829/1830: per-session Ansuz handoff slots. Must live here, not in
+  # state_files — the prefix match that covers <session_id>.json is static_paths-only.
+  - .kenaz/specialist/handoffs/
+  # TASK_1957: cross-project worktree dispatch (esp32 TASK_82/83) committed
+  # .kenaz/sessions/canary_*.json and .formation/.dispatch-branch into the task
+  # branch (neither was previously in this manifest), then post-complete's
+  # merge collided with the sub-project main's own live copies of those paths
+  # ("would be overwritten"). buildWorktreeGitAddCommand() (prompt.js /
+  # utils.js) now excludes both from the commit-time `git add -A` at the
+  # source, but they are listed here too as a second layer — so
+  # revertDaemonManagedFiles()/getDaemonPathsToUnstage() also clean up any
+  # copy that already landed in a sub-project's history before this fix.
+  - .kenaz/sessions/
+  - .formation/.dispatch-branch
+  - .formation/.parallel-count
+  - .formation/.parallel-count-lock
+  - .formation/.active-dispatches.json
+  - .formation/analytics/
+  - .formation/state/
+  - .synapse/db/index_state.json
+  - .synapse/memory-shared.json
+  - .synapse/pulse_cache.json
+  - .synapse/heat_cache.json
+  - .synapse/reflex_neurons.json
+  - .memory/registry.json
+  - .prefrontal/generalize_counter.json
+  - .tmp/
+  - claude
+  - .formation/signals/
+  - .formation/.synapse/
+  # TASK_1622: one-off probe/episode-writer scripts created by Muninn/Ansuz during
+  # live sessions. These are never intentional task output; excludes them from
+  # recovery commits (git add -A in worktree) to prevent probe files being swept in.
+  - .formation/tmp_muninn_identity.js
+  - .formation/tmp_muninn_runes.js
+  - .formation/tmp_muninn_session.js
+  - .formation/tmp_verify_runes.js
+  - .formation/tmp_episode_start.json
+  - .formation/muninn_snapshot_4.js
+  - .formation/muninn_rune_check.js
+  - .formation/episode_writer.js
+  - .formation/episode_writer_v2.js