@adaptic/maestro 1.0.0

package/docs/superpowers/plans/2026-04-06-session-context-dedup.md

@@ -0,0 +1,1994 @@
+# Session Context & Dedup Overhaul — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Eliminate duplicate responses and inject pre-compiled conversational context into every daemon-spawned session, with information barrier filtering.
+
+**Architecture:** Two new modules (`session-lock.mjs` for file-based dedup/locking, `context-compiler.mjs` for pre-compiling context), plus integration changes to the four existing daemon modules. Feature-flagged via `DAEMON_CONTEXT_COMPILER=1`.
+
+**Tech Stack:** Node.js ESM, `node:test` + `node:assert` for tests, file-based persistence (JSON/JSONL), YAML parsing via string matching (no new deps).
+
+**Spec:** `docs/superpowers/specs/2026-04-06-session-context-dedup-design.md`
+
+---
+
+## File Structure
+
+### New Files
+
+| File | Responsibility |
+|------|---------------|
+| `scripts/daemon/session-lock.mjs` | File-based item locks + sent-message registry. Exports: `acquireLock`, `releaseLock`, `updateLock`, `readLock`, `scanStaleLocks`, `checkRecentlySent`, `registerSent`, `sanitiseItemId` |
+| `scripts/daemon/context-compiler.mjs` | Pre-compiles sender profile, disclosure boundaries, conversation history, active sessions, and sent-messages into a single context block. Exports: `compileContext` |
+| `scripts/daemon/test-session-lock.mjs` | Unit tests for session-lock module |
+| `scripts/daemon/test-context-compiler.mjs` | Unit tests for context-compiler module |
+| `scripts/daemon/test-integration.mjs` | Integration tests for the full pipeline |
+| `state/sessions/active.json` | Live manifest of currently running sessions |
+| `state/sessions/locks/` | Directory for per-item lock files |
+| `state/sessions/sent-registry.jsonl` | Append-only log of all sent messages |
+
+### Modified Files
+
+| File | Change Summary |
+|------|---------------|
+| `scripts/daemon/sophie-daemon.mjs` | Remove in-memory dedup, use `acquireLock`/`releaseLock`, call `scanStaleLocks` on startup |
+| `scripts/daemon/dispatcher.mjs` | Write/remove `active.json` entries, call `releaseLock` on session close, stabilise `backlogKey` |
+| `scripts/daemon/prompt-builder.mjs` | Replace `loadConversationHistory` and profile-read instruction with `compileContext` output, feature flag |
+| `scripts/daemon/responder.mjs` | Call `checkRecentlySent` before sending, `registerSent` after sending |
+
+---
+
+## Task 1: Create State Directory Structure
+
+**Files:**
+- Create: `state/sessions/active.json`
+- Create: `state/sessions/locks/.gitkeep`
+- Create: `state/sessions/sent-registry.jsonl`
+
+- [ ] **Step 1: Create the directories and seed files**
+
+```bash
+mkdir -p state/sessions/locks
+echo '{}' > state/sessions/active.json
+touch state/sessions/sent-registry.jsonl
+touch state/sessions/locks/.gitkeep
+```
+
+- [ ] **Step 2: Add to .gitignore (lock files and registry are ephemeral)**
+
+Add to the project `.gitignore`:
+
+```
+# Session state (ephemeral — regenerated at runtime)
+state/sessions/locks/*.lock
+state/sessions/sent-registry.jsonl
+```
+
+Keep `active.json` tracked (seed file) and `locks/.gitkeep` tracked (preserves directory).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add state/sessions/active.json state/sessions/locks/.gitkeep .gitignore
+git commit -m "chore: create state/sessions directory structure for session locks and context"
+```
+
+---
+
+## Task 2: Implement Session Lock Module
+
+**Files:**
+- Create: `scripts/daemon/session-lock.mjs`
+- Test: `scripts/daemon/test-session-lock.mjs`
+
+- [ ] **Step 1: Write failing tests for `sanitiseItemId`**
+
+Create `scripts/daemon/test-session-lock.mjs`:
+
+```javascript
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// Tests use a temporary directory to avoid polluting real state
+const TEST_DIR = join(import.meta.dirname, "../../.test-session-locks");
+const LOCKS_DIR = join(TEST_DIR, "locks");
+const REGISTRY_PATH = join(TEST_DIR, "sent-registry.jsonl");
+
+// We'll set these env vars so the module uses our test paths
+process.env.__TEST_SESSION_DIR = TEST_DIR;
+
+const {
+  sanitiseItemId,
+  acquireLock,
+  releaseLock,
+  updateLock,
+  readLock,
+  scanStaleLocks,
+  checkRecentlySent,
+  registerSent,
+} = await import("./session-lock.mjs");
+
+describe("sanitiseItemId", () => {
+  it("replaces colons and dots with hyphens", () => {
+    assert.equal(
+      sanitiseItemId("slack:D099N1JGKRQ:1775331885.690669"),
+      "slack-D099N1JGKRQ-1775331885-690669"
+    );
+  });
+
+  it("handles simple alphanumeric IDs unchanged", () => {
+    assert.equal(sanitiseItemId("abc123"), "abc123");
+  });
+
+  it("replaces spaces and special chars", () => {
+    assert.equal(sanitiseItemId("foo bar/baz@qux"), "foo-bar-baz-qux");
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs
+```
+
+Expected: FAIL — `session-lock.mjs` does not exist.
+
+- [ ] **Step 3: Write the session-lock module skeleton with `sanitiseItemId`**
+
+Create `scripts/daemon/session-lock.mjs`:
+
+```javascript
+#!/usr/bin/env node
+/**
+ * session-lock.mjs — File-based session locks and sent-message registry
+ *
+ * Replaces the in-memory recentlyProcessed Map in sophie-daemon.mjs with
+ * persistent, atomic file locks that survive daemon restarts and prevent
+ * race conditions between concurrent polls.
+ *
+ * Also provides a sent-message registry to prevent duplicate sends even
+ * when locking fails (belt + suspenders).
+ */
+
+import {
+  writeFileSync,
+  readFileSync,
+  unlinkSync,
+  readdirSync,
+  appendFileSync,
+  mkdirSync,
+  existsSync,
+  statSync,
+} from "fs";
+import { join } from "path";
+
+// Allow test override of state directory
+const SOPHIE_AI_DIR = join(new URL(".", import.meta.url).pathname, "../..");
+const SESSION_DIR = process.env.__TEST_SESSION_DIR || join(SOPHIE_AI_DIR, "state", "sessions");
+const LOCKS_DIR = join(SESSION_DIR, "locks");
+const REGISTRY_PATH = join(SESSION_DIR, "sent-registry.jsonl");
+
+const STALE_LOCK_MS = 15 * 60 * 1000; // 15 min — matches OPUS_TIMEOUT
+const SENT_DEDUP_WINDOW_MS = 5 * 60 * 1000; // 5 min
+const SENT_SUBSTANTIVE_WINDOW_MS = 2 * 60 * 1000; // 2 min for same-person substantive
+const MAX_REGISTRY_ENTRIES = 500; // Keep registry file manageable
+
+// Ensure directories exist
+mkdirSync(LOCKS_DIR, { recursive: true });
+
+/**
+ * Sanitise an item ID for use as a filename.
+ * Replaces all non-alphanumeric characters with hyphens.
+ */
+export function sanitiseItemId(itemId) {
+  return itemId.replace(/[^a-zA-Z0-9]/g, "-");
+}
+```
+
+- [ ] **Step 4: Run test to verify `sanitiseItemId` passes**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs
+```
+
+Expected: 3 tests pass.
+
+- [ ] **Step 5: Write failing tests for `acquireLock` / `releaseLock` / `readLock`**
+
+Append to `scripts/daemon/test-session-lock.mjs`:
+
+```javascript
+describe("acquireLock / releaseLock / readLock", () => {
+  beforeEach(() => {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("acquires a lock on first call", () => {
+    const result = acquireLock("test-item-1", { sender: "Alice", channel: "C001" });
+    assert.equal(result.acquired, true);
+    assert.equal(existsSync(join(LOCKS_DIR, "test-item-1.lock")), true);
+  });
+
+  it("rejects second acquire for same item", () => {
+    acquireLock("test-item-2", { sender: "Alice", channel: "C001" });
+    const result = acquireLock("test-item-2", { sender: "Bob", channel: "C002" });
+    assert.equal(result.acquired, false);
+    assert.ok(result.existing);
+    assert.equal(result.existing.sender, "Alice");
+  });
+
+  it("allows acquire after release", () => {
+    acquireLock("test-item-3", { sender: "Alice", channel: "C001" });
+    releaseLock("test-item-3");
+    const result = acquireLock("test-item-3", { sender: "Bob", channel: "C002" });
+    assert.equal(result.acquired, true);
+  });
+
+  it("readLock returns lock data when locked", () => {
+    acquireLock("test-item-4", { sender: "Alice", channel: "C001" });
+    const data = readLock("test-item-4");
+    assert.equal(data.sender, "Alice");
+    assert.equal(data.channel, "C001");
+    assert.equal(data.holdingSent, false);
+    assert.equal(data.substantiveSent, false);
+  });
+
+  it("readLock returns null when no lock", () => {
+    const data = readLock("nonexistent-item");
+    assert.equal(data, null);
+  });
+
+  it("overwrites stale lock (>15 min old)", () => {
+    // Write a lock with an old timestamp
+    const lockPath = join(LOCKS_DIR, "test-item-5.lock");
+    mkdirSync(LOCKS_DIR, { recursive: true });
+    const staleLock = {
+      sessionId: "old-session",
+      itemId: "test-item-5",
+      sender: "Alice",
+      channel: "C001",
+      acquiredAt: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
+      holdingSent: false,
+      substantiveSent: false,
+    };
+    writeFileSync(lockPath, JSON.stringify(staleLock));
+
+    const result = acquireLock("test-item-5", { sender: "Bob", channel: "C002" });
+    assert.equal(result.acquired, true);
+    const data = readLock("test-item-5");
+    assert.equal(data.sender, "Bob");
+  });
+});
+```
+
+- [ ] **Step 6: Run test to verify new tests fail**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs
+```
+
+Expected: `sanitiseItemId` tests pass, lock tests fail (`acquireLock` not exported).
+
+- [ ] **Step 7: Implement `acquireLock`, `releaseLock`, `readLock`**
+
+Append to `scripts/daemon/session-lock.mjs`:
+
+```javascript
+/**
+ * Attempt to acquire a lock for an item.
+ * Uses exclusive file creation (wx flag) for atomicity.
+ *
+ * @param {string} itemId - Raw item ID (will be sanitised)
+ * @param {object} metadata - { sender, channel, sessionId? }
+ * @returns {{ acquired: boolean, existing?: object }}
+ */
+export function acquireLock(itemId, metadata = {}) {
+  const safeId = sanitiseItemId(itemId);
+  const lockPath = join(LOCKS_DIR, `${safeId}.lock`);
+
+  // Check for existing lock
+  if (existsSync(lockPath)) {
+    try {
+      const existing = JSON.parse(readFileSync(lockPath, "utf-8"));
+      const age = Date.now() - new Date(existing.acquiredAt).getTime();
+
+      // If lock is fresh (< STALE_LOCK_MS), reject
+      if (age < STALE_LOCK_MS) {
+        return { acquired: false, existing };
+      }
+      // Stale lock — fall through to overwrite
+    } catch {
+      // Corrupted lock file — overwrite
+    }
+  }
+
+  const lockData = {
+    sessionId: metadata.sessionId || `pending-${Date.now()}`,
+    itemId,
+    channel: metadata.channel || null,
+    sender: metadata.sender || null,
+    acquiredAt: new Date().toISOString(),
+    holdingSent: false,
+    substantiveSent: false,
+  };
+
+  try {
+    // Try exclusive create first (atomic)
+    writeFileSync(lockPath, JSON.stringify(lockData, null, 2), { flag: "wx" });
+    return { acquired: true };
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      // Another process beat us — check if it's stale
+      try {
+        const existing = JSON.parse(readFileSync(lockPath, "utf-8"));
+        const age = Date.now() - new Date(existing.acquiredAt).getTime();
+        if (age >= STALE_LOCK_MS) {
+          // Stale — overwrite (non-atomic but acceptable for stale locks)
+          writeFileSync(lockPath, JSON.stringify(lockData, null, 2));
+          return { acquired: true };
+        }
+        return { acquired: false, existing };
+      } catch {
+        return { acquired: false };
+      }
+    }
+    throw err;
+  }
+}
+
+/**
+ * Release a lock for an item.
+ * @param {string} itemId - Raw item ID (will be sanitised)
+ */
+export function releaseLock(itemId) {
+  const safeId = sanitiseItemId(itemId);
+  const lockPath = join(LOCKS_DIR, `${safeId}.lock`);
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    // Lock already released or never existed — fine
+  }
+}
+
+/**
+ * Read the lock data for an item without modifying it.
+ * @param {string} itemId - Raw item ID (will be sanitised)
+ * @returns {object|null} Lock data or null if no lock
+ */
+export function readLock(itemId) {
+  const safeId = sanitiseItemId(itemId);
+  const lockPath = join(LOCKS_DIR, `${safeId}.lock`);
+  try {
+    return JSON.parse(readFileSync(lockPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+```
+
+- [ ] **Step 8: Run tests to verify lock tests pass**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 9: Write failing tests for `updateLock` and `scanStaleLocks`**
+
+Append to `scripts/daemon/test-session-lock.mjs`:
+
+```javascript
+describe("updateLock", () => {
+  beforeEach(() => {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("updates holdingSent flag on existing lock", () => {
+    acquireLock("test-item-6", { sender: "Alice", channel: "C001" });
+    updateLock("test-item-6", { holdingSent: true });
+    const data = readLock("test-item-6");
+    assert.equal(data.holdingSent, true);
+    assert.equal(data.substantiveSent, false);
+  });
+
+  it("no-ops when lock does not exist", () => {
+    // Should not throw
+    updateLock("nonexistent", { holdingSent: true });
+  });
+});
+
+describe("scanStaleLocks", () => {
+  beforeEach(() => {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("clears stale locks and leaves fresh ones", () => {
+    // Fresh lock
+    acquireLock("fresh-item", { sender: "Alice", channel: "C001" });
+
+    // Stale lock (manually written with old timestamp)
+    const stalePath = join(LOCKS_DIR, "stale-item.lock");
+    writeFileSync(stalePath, JSON.stringify({
+      sessionId: "old", itemId: "stale-item", sender: "Bob", channel: "C002",
+      acquiredAt: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
+      holdingSent: false, substantiveSent: false,
+    }));
+
+    const cleared = scanStaleLocks();
+    assert.equal(cleared, 1);
+    assert.equal(existsSync(join(LOCKS_DIR, "fresh-item.lock")), true);
+    assert.equal(existsSync(stalePath), false);
+  });
+});
+```
+
+- [ ] **Step 10: Implement `updateLock` and `scanStaleLocks`**
+
+Append to `scripts/daemon/session-lock.mjs`:
+
+```javascript
+/**
+ * Update fields on an existing lock.
+ * @param {string} itemId - Raw item ID
+ * @param {object} updates - Fields to merge (e.g., { holdingSent: true })
+ */
+export function updateLock(itemId, updates) {
+  const safeId = sanitiseItemId(itemId);
+  const lockPath = join(LOCKS_DIR, `${safeId}.lock`);
+  try {
+    const existing = JSON.parse(readFileSync(lockPath, "utf-8"));
+    const updated = { ...existing, ...updates };
+    writeFileSync(lockPath, JSON.stringify(updated, null, 2));
+  } catch {
+    // Lock doesn't exist — no-op
+  }
+}
+
+/**
+ * Scan and remove stale locks (older than STALE_LOCK_MS).
+ * Call on daemon startup to clean up after crashes.
+ * @returns {number} Number of stale locks cleared
+ */
+export function scanStaleLocks() {
+  let cleared = 0;
+  try {
+    const files = readdirSync(LOCKS_DIR).filter((f) => f.endsWith(".lock"));
+    for (const file of files) {
+      const lockPath = join(LOCKS_DIR, file);
+      try {
+        const data = JSON.parse(readFileSync(lockPath, "utf-8"));
+        const age = Date.now() - new Date(data.acquiredAt).getTime();
+        if (age >= STALE_LOCK_MS) {
+          unlinkSync(lockPath);
+          cleared++;
+        }
+      } catch {
+        // Corrupted lock — remove it
+        try { unlinkSync(lockPath); cleared++; } catch {}
+      }
+    }
+  } catch {
+    // LOCKS_DIR doesn't exist yet — nothing to scan
+  }
+  return cleared;
+}
+```
+
+- [ ] **Step 11: Run tests to verify all pass**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 12: Write failing tests for sent-message registry**
+
+Append to `scripts/daemon/test-session-lock.mjs`:
+
+```javascript
+describe("sent-message registry", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    // Ensure clean registry
+    try { unlinkSync(REGISTRY_PATH); } catch {}
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("allows first send to a channel", () => {
+    const result = checkRecentlySent("C001", "1234.5678", "holding");
+    assert.equal(result.allowed, true);
+  });
+
+  it("blocks duplicate send to same channel+thread+type within window", () => {
+    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
+    const result = checkRecentlySent("C001", "1234.5678", "holding");
+    assert.equal(result.allowed, false);
+    assert.ok(result.reason.includes("duplicate"));
+  });
+
+  it("allows different type to same channel+thread", () => {
+    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
+    const result = checkRecentlySent("C001", "1234.5678", "substantive");
+    assert.equal(result.allowed, true);
+  });
+
+  it("allows same type to different channel", () => {
+    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
+    const result = checkRecentlySent("C002", "1234.5678", "holding");
+    assert.equal(result.allowed, true);
+  });
+
+  it("blocks rapid substantive sends to same channel even with different threads", () => {
+    registerSent("C001", "1111.0000", "substantive", "s-1", "Here is the answer");
+    const result = checkRecentlySent("C001", "2222.0000", "substantive");
+    assert.equal(result.allowed, false);
+    assert.ok(result.reason.includes("rapid"));
+  });
+});
+```
+
+- [ ] **Step 13: Implement `registerSent` and `checkRecentlySent`**
+
+Append to `scripts/daemon/session-lock.mjs`:
+
+```javascript
+/**
+ * Register that a message was sent.
+ * @param {string} channel - Slack channel ID or email address
+ * @param {string|null} threadTs - Thread timestamp (null for non-threaded)
+ * @param {string} type - "holding" | "quick_reply" | "substantive"
+ * @param {string} sessionId - Session that sent it
+ * @param {string} textPreview - First ~100 chars of the message
+ */
+export function registerSent(channel, threadTs, type, sessionId, textPreview) {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    channel,
+    threadTs: threadTs || null,
+    type,
+    sessionId,
+    textPreview: (textPreview || "").substring(0, 100),
+  };
+  try {
+    appendFileSync(REGISTRY_PATH, JSON.stringify(entry) + "\n");
+  } catch {
+    // Registry dir might not exist yet in tests
+    mkdirSync(SESSION_DIR, { recursive: true });
+    appendFileSync(REGISTRY_PATH, JSON.stringify(entry) + "\n");
+  }
+}
+
+/**
+ * Check if a similar message was recently sent to the same channel/thread.
+ * @param {string} channel
+ * @param {string|null} threadTs
+ * @param {string} type - "holding" | "quick_reply" | "substantive"
+ * @returns {{ allowed: boolean, reason?: string }}
+ */
+export function checkRecentlySent(channel, threadTs, type) {
+  let entries = [];
+  try {
+    const raw = readFileSync(REGISTRY_PATH, "utf-8").trim();
+    if (!raw) return { allowed: true };
+    const lines = raw.split("\n").filter(Boolean);
+    // Only check recent entries (last MAX_REGISTRY_ENTRIES lines)
+    const recent = lines.slice(-MAX_REGISTRY_ENTRIES);
+    entries = recent.map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    // No registry file yet — nothing sent
+    return { allowed: true };
+  }
+
+  const now = Date.now();
+
+  // Rule 1: Same channel + thread + type within 5 min → BLOCK
+  const exactMatch = entries.find((e) => {
+    const age = now - new Date(e.timestamp).getTime();
+    return e.channel === channel
+      && e.threadTs === (threadTs || null)
+      && e.type === type
+      && age < SENT_DEDUP_WINDOW_MS;
+  });
+  if (exactMatch) {
+    return { allowed: false, reason: `duplicate: same channel+thread+type sent ${Math.round((now - new Date(exactMatch.timestamp).getTime()) / 1000)}s ago` };
+  }
+
+  // Rule 2: Same channel + substantive within 2 min (any thread) → BLOCK
+  if (type === "substantive") {
+    const rapidMatch = entries.find((e) => {
+      const age = now - new Date(e.timestamp).getTime();
+      return e.channel === channel
+        && e.type === "substantive"
+        && age < SENT_SUBSTANTIVE_WINDOW_MS;
+    });
+    if (rapidMatch) {
+      return { allowed: false, reason: `rapid: substantive message to same channel sent ${Math.round((now - new Date(rapidMatch.timestamp).getTime()) / 1000)}s ago` };
+    }
+  }
+
+  return { allowed: true };
+}
+```
+
+- [ ] **Step 14: Run all session-lock tests**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs
+```
+
+Expected: All tests pass (sanitiseItemId + lock lifecycle + registry).
+
+- [ ] **Step 15: Commit**
+
+```bash
+git add scripts/daemon/session-lock.mjs scripts/daemon/test-session-lock.mjs
+git commit -m "feat: file-based session locks and sent-message registry
+
+Replaces in-memory dedup Map with persistent file locks using atomic
+exclusive-create (wx flag). Adds sent-message registry to prevent
+duplicate sends even when locking fails. All tests passing."
+```
+
+---
+
+## Task 3: Implement Context Compiler
+
+**Files:**
+- Create: `scripts/daemon/context-compiler.mjs`
+- Test: `scripts/daemon/test-context-compiler.mjs`
+
+- [ ] **Step 1: Write failing tests for token budget determination**
+
+Create `scripts/daemon/test-context-compiler.mjs`:
+
+```javascript
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const TEST_DIR = join(import.meta.dirname, "../../.test-context-compiler");
+process.env.__TEST_SOPHIE_DIR = TEST_DIR;
+
+// Create minimal directory structure needed
+function setupTestDir() {
+  mkdirSync(join(TEST_DIR, "memory", "profiles", "users"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alice-smith"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "D001TESTCH"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "policies"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "state", "sessions"), { recursive: true });
+  writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), "{}");
+}
+
+function cleanTestDir() {
+  rmSync(TEST_DIR, { recursive: true, force: true });
+}
+
+// Write a minimal information-barriers.yaml for tests
+function writeBarriersPolicy() {
+  writeFileSync(join(TEST_DIR, "policies", "information-barriers.yaml"), `domains:
+  adaptic-internal-legal:
+    description: "Adaptic's own legal strategy, GC advice, privilege-protected"
+    default_sensitivity: high
+  rollup-strategy:
+    description: "Project Aether M&A targets, deal terms, pipeline"
+    default_sensitivity: critical
+  ftlab-operations:
+    description: "FTLab JV operational matters"
+    default_sensitivity: low
+  public:
+    description: "Published information, press, website — no restrictions"
+    default_sensitivity: none
+`);
+}
+
+describe("compileContext", () => {
+  beforeEach(() => {
+    setupTestDir();
+    writeBarriersPolicy();
+  });
+
+  afterEach(() => {
+    cleanTestDir();
+  });
+
+  it("returns adaptive token budget based on priority", async () => {
+    const { compileContext } = await import("./context-compiler.mjs");
+
+    const criticalResult = await compileContext(
+      { sender: "Unknown", channel: "C001" },
+      { priority: "critical", model: "opus", action: "respond" },
+      {}
+    );
+    assert.ok(criticalResult.tokenBudget >= 12000);
+
+    const normalResult = await compileContext(
+      { sender: "Unknown", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(normalResult.tokenBudget >= 8000 && normalResult.tokenBudget < 12000);
+
+    const lowResult = await compileContext(
+      { sender: "Unknown", channel: "C001" },
+      { priority: "low", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(lowResult.tokenBudget >= 4000 && lowResult.tokenBudget < 8000);
+  });
+
+  it("includes sender profile when available", async () => {
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"),
+      `name: Alice Smith\nrole: Partner\nprivilege_level: leadership\ncommunication_preferences:\n  voice: formal\n`
+    );
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Alice Smith", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(result.contextBlock.includes("Alice Smith"));
+    assert.ok(result.contextBlock.includes("Sender Profile"));
+  });
+
+  it("produces minimal block when no profile exists", async () => {
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Nobody Special", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(result.contextBlock.includes("COMPILED CONTEXT"));
+    // Should not crash, should still have section headers
+    assert.ok(result.contextBlock.includes("END CONTEXT"));
+  });
+
+  it("filters history by disclosure boundaries", async () => {
+    // Profile with excluded domains
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"),
+      `name: Alice Smith\nrole: Partner\ninformation_boundaries:\n  excluded_domains:\n    - rollup-strategy\n    - adaptic-internal-legal\n`
+    );
+
+    // History with mixed domain content
+    const historyDir = join(TEST_DIR, "memory", "interactions", "slack", "dm-alice-smith");
+    const today = new Date().toISOString().split("T")[0];
+    writeFileSync(join(historyDir, `${today}.jsonl`), [
+      JSON.stringify({ ts: "1000", from: "alice-smith", content: "How is the FTLab project going?", received_at: "2026-04-06T10:00:00Z" }),
+      JSON.stringify({ ts: "1001", from: "sophie", content: "Project Aether acquisition target list has 9 candidates", received_at: "2026-04-06T10:01:00Z" }),
+      JSON.stringify({ ts: "1002", from: "sophie", content: "The FTLab operations are on track", received_at: "2026-04-06T10:02:00Z" }),
+      JSON.stringify({ ts: "1003", from: "sophie", content: "GC advice on the legal strategy is privileged", received_at: "2026-04-06T10:03:00Z" }),
+    ].join("\n") + "\n");
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Alice Smith", channel: "D001TESTCH", channel_id: "D001TESTCH" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+
+    // FTLab operations message should be included
+    assert.ok(result.contextBlock.includes("FTLab operations are on track"));
+    assert.ok(result.contextBlock.includes("FTLab project going"));
+    // Rollup strategy and legal messages should be filtered out
+    assert.ok(!result.contextBlock.includes("Aether acquisition target"));
+    assert.ok(!result.contextBlock.includes("GC advice"));
+  });
+
+  it("includes disclosure boundaries block with restrictions", async () => {
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"),
+      `name: Alice Smith\ninformation_boundaries:\n  excluded_domains:\n    - rollup-strategy\n    - adaptic-internal-legal\n`
+    );
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Alice Smith", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(result.contextBlock.includes("Disclosure Boundaries"));
+    assert.ok(result.contextBlock.includes("DO NOT mention"));
+  });
+
+  it("includes active sessions when present", async () => {
+    writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), JSON.stringify({
+      "s-100": { sender: "Bob", channel: "C002", summary: "Draft investor deck", model: "opus", startTime: Date.now() - 60000 }
+    }));
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Unknown", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(result.contextBlock.includes("Active Sessions"));
+    assert.ok(result.contextBlock.includes("Draft investor deck"));
+  });
+
+  it("includes sent-registry entries for same sender", async () => {
+    writeFileSync(join(TEST_DIR, "state", "sessions", "sent-registry.jsonl"),
+      JSON.stringify({
+        timestamp: new Date().toISOString(),
+        channel: "D001TESTCH",
+        threadTs: null,
+        type: "holding",
+        sessionId: "s-1",
+        textPreview: "Got it, looking into this now."
+      }) + "\n"
+    );
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Unknown", channel: "D001TESTCH", channel_id: "D001TESTCH" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+    assert.ok(result.contextBlock.includes("Already Sent"));
+    assert.ok(result.contextBlock.includes("Got it, looking into this"));
+  });
+
+  it("CEO gets all domains — no filtering", async () => {
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "mehran-granfar.yaml"),
+      `name: Mehran Granfar\nprivilege_level: ceo\n`
+    );
+
+    const historyDir = join(TEST_DIR, "memory", "interactions", "slack", "dm-mehran-granfar");
+    mkdirSync(historyDir, { recursive: true });
+    const today = new Date().toISOString().split("T")[0];
+    writeFileSync(join(historyDir, `${today}.jsonl`), [
+      JSON.stringify({ ts: "1000", from: "sophie", content: "Project Aether target list updated", received_at: "2026-04-06T10:00:00Z" }),
+      JSON.stringify({ ts: "1001", from: "sophie", content: "GC legal strategy memo ready", received_at: "2026-04-06T10:01:00Z" }),
+    ].join("\n") + "\n");
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const result = await compileContext(
+      { sender: "Mehran Granfar", channel: "D099CEO", channel_id: "D099CEO" },
+      { priority: "critical", model: "opus", action: "respond" },
+      {}
+    );
+    // CEO should see everything
+    assert.ok(result.contextBlock.includes("Aether target list"));
+    assert.ok(result.contextBlock.includes("legal strategy memo"));
+    assert.ok(!result.contextBlock.includes("DO NOT mention"));
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+```bash
+node --test scripts/daemon/test-context-compiler.mjs
+```
+
+Expected: FAIL — `context-compiler.mjs` does not exist.
+
+- [ ] **Step 3: Implement the context compiler**
+
+Create `scripts/daemon/context-compiler.mjs`:
+
+```javascript
+#!/usr/bin/env node
+/**
+ * context-compiler.mjs — Pre-compile session context
+ *
+ * Assembles sender profile, disclosure boundaries, conversation history,
+ * active session state, and sent-message registry into a single context
+ * block injected into every dispatched session's prompt.
+ *
+ * Key principle: sessions receive pre-filtered context as data, not
+ * instructions to navigate the filesystem.
+ */
+
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join } from "path";
+
+const SOPHIE_AI_DIR = process.env.__TEST_SOPHIE_DIR
+  || join(new URL(".", import.meta.url).pathname, "../..");
+const SESSION_DIR = process.env.__TEST_SESSION_DIR
+  || join(SOPHIE_AI_DIR, "state", "sessions");
+
+// Approximate chars-per-token ratio for budget calculations
+const CHARS_PER_TOKEN = 4;
+
+// Token budgets by priority tier
+const TOKEN_BUDGETS = {
+  critical: 12000,
+  high: 12000,
+  normal: 8000,
+  low: 4000,
+};
+
+// Fixed allocations (tokens)
+const PROFILE_BUDGET = 500;
+const BOUNDARIES_BUDGET = 300;
+const ACTIVE_SESSIONS_BUDGET = 300;
+const SENT_REGISTRY_BUDGET = 500;
+
+/**
+ * Main entry point: compile all context for a session.
+ *
+ * @param {object} item - Inbox item (sender, channel, channel_id, raw_ref, etc.)
+ * @param {object} classResult - Classifier output (priority, model, action)
+ * @param {object} options - { type?: "inbox"|"backlog" }
+ * @returns {{ contextBlock: string, tokenBudget: number, tokenEstimate: number }}
+ */
+export async function compileContext(item, classResult, options = {}) {
+  const totalBudget = TOKEN_BUDGETS[classResult.priority] || TOKEN_BUDGETS.normal;
+  const historyBudget = totalBudget - PROFILE_BUDGET - BOUNDARIES_BUDGET - ACTIVE_SESSIONS_BUDGET - SENT_REGISTRY_BUDGET;
+
+  const senderSlug = item.sender ? item.sender.replace(/\s+/g, "-").toLowerCase() : null;
+  const channelId = extractChannelId(item);
+
+  // Step 2: Load user profile
+  const profileSection = loadUserProfile(senderSlug, PROFILE_BUDGET);
+
+  // Step 3: Load disclosure boundaries
+  const { boundariesSection, forbiddenDomains } = loadDisclosureBoundaries(senderSlug, BOUNDARIES_BUDGET);
+
+  // Step 4: Load conversation history (filtered by disclosure boundaries)
+  const historySection = loadConversationHistory(senderSlug, channelId, historyBudget, forbiddenDomains);
+
+  // Step 5: Load active sessions
+  const activeSection = loadActiveSessions(ACTIVE_SESSIONS_BUDGET);
+
+  // Step 6: Load sent-message registry
+  const sentSection = loadSentRegistry(channelId, SENT_REGISTRY_BUDGET);
+
+  // Step 7: Assemble
+  const sections = [
+    "--- COMPILED CONTEXT (do not repeat verbatim) ---",
+    "",
+  ];
+
+  if (profileSection) {
+    sections.push("## Sender Profile", profileSection, "");
+  }
+
+  if (boundariesSection) {
+    sections.push("## Disclosure Boundaries", boundariesSection, "");
+  }
+
+  if (historySection) {
+    sections.push("## Conversation History (most recent last)", historySection, "");
+  } else {
+    sections.push("## Conversation History", "No prior conversation history found.", "");
+  }
+
+  if (activeSection) {
+    sections.push("## Active Sessions", activeSection, "");
+  }
+
+  if (sentSection) {
+    sections.push("## Already Sent", sentSection, "");
+  }
+
+  sections.push("--- END CONTEXT ---");
+
+  const contextBlock = sections.join("\n");
+  const tokenEstimate = Math.ceil(contextBlock.length / CHARS_PER_TOKEN);
+
+  return { contextBlock, tokenBudget: totalBudget, tokenEstimate };
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function extractChannelId(item) {
+  if (!item) return null;
+  if (item.channel_id) return item.channel_id;
+  if (item.raw_ref) {
+    const match = item.raw_ref.match(/slack:([DC][A-Z0-9]+):/);
+    if (match) return match[1];
+  }
+  if (item.channel && /^[DC][A-Z0-9]{8,}$/.test(item.channel)) return item.channel;
+  return null;
+}
+
+function loadUserProfile(senderSlug, budget) {
+  if (!senderSlug) return null;
+  const profilePath = join(SOPHIE_AI_DIR, "memory", "profiles", "users", `${senderSlug}.yaml`);
+  try {
+    const raw = readFileSync(profilePath, "utf-8");
+    // Truncate to budget
+    const maxChars = budget * CHARS_PER_TOKEN;
+    return raw.substring(0, maxChars);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load disclosure boundaries from the sender's profile.
+ * Returns the boundaries section text and the list of forbidden domains.
+ */
+function loadDisclosureBoundaries(senderSlug, budget) {
+  if (!senderSlug) {
+    return {
+      boundariesSection: "ALLOWED domains: public only. DO NOT mention or reference any internal Adaptic information.",
+      forbiddenDomains: getAllDomains(),
+    };
+  }
+
+  // Read sender profile to find excluded domains
+  const profilePath = join(SOPHIE_AI_DIR, "memory", "profiles", "users", `${senderSlug}.yaml`);
+  let excludedDomains = [];
+  let privilegeLevel = "unknown";
+
+  try {
+    const raw = readFileSync(profilePath, "utf-8");
+
+    // Parse privilege_level
+    const privMatch = raw.match(/privilege_level:\s*(\S+)/);
+    if (privMatch) privilegeLevel = privMatch[1];
+
+    // CEO sees everything — no restrictions
+    if (privilegeLevel === "ceo") {
+      return { boundariesSection: null, forbiddenDomains: [] };
+    }
+
+    // Parse excluded_domains list
+    const boundaryBlock = raw.match(/information_boundaries:[\s\S]*?(?=\n\S|\n$|$)/);
+    if (boundaryBlock) {
+      const excludedMatch = boundaryBlock[0].match(/excluded_domains:\s*\n((?:\s+-\s+.+\n?)*)/);
+      if (excludedMatch) {
+        excludedDomains = excludedMatch[1]
+          .split("\n")
+          .map((line) => line.replace(/^\s*-\s*/, "").trim())
+          .filter(Boolean);
+      }
+    }
+  } catch {
+    // No profile — treat as unknown sender, restrict to public
+    return {
+      boundariesSection: "ALLOWED domains: public only. DO NOT mention or reference any internal Adaptic information.",
+      forbiddenDomains: getAllDomains(),
+    };
+  }
+
+  if (excludedDomains.length === 0) {
+    return { boundariesSection: null, forbiddenDomains: [] };
+  }
+
+  // Build human-readable restrictions from domain descriptions
+  const domainDescriptions = loadDomainDescriptions();
+  const restrictions = excludedDomains
+    .map((d) => `- ${domainDescriptions[d] || d}`)
+    .join("\n");
+
+  const boundariesSection = `DO NOT mention or reference:\n${restrictions}`;
+
+  return { boundariesSection, forbiddenDomains: excludedDomains };
+}
+
+/**
+ * Load all domain names from information-barriers.yaml.
+ * Used when sender is unknown — restrict everything except public.
+ */
+function getAllDomains() {
+  const descriptions = loadDomainDescriptions();
+  return Object.keys(descriptions).filter((d) => d !== "public");
+}
+
+/**
+ * Load domain name → description map from information-barriers.yaml.
+ */
+function loadDomainDescriptions() {
+  const barriersPath = join(SOPHIE_AI_DIR, "policies", "information-barriers.yaml");
+  try {
+    const raw = readFileSync(barriersPath, "utf-8");
+    const descriptions = {};
+    const domainMatches = raw.matchAll(/^\s{2}([\w-]+):\s*\n\s+description:\s*"(.+?)"/gm);
+    for (const m of domainMatches) {
+      descriptions[m[1]] = m[2];
+    }
+    return descriptions;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Build keyword patterns for each domain, used to filter history entries.
+ * Keywords are extracted from domain descriptions in information-barriers.yaml.
+ */
+function buildDomainKeywords() {
+  const descriptions = loadDomainDescriptions();
+  const keywords = {};
+  for (const [domain, desc] of Object.entries(descriptions)) {
+    // Extract significant words from description (4+ chars, lowercased)
+    keywords[domain] = desc
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, "")
+      .split(/\s+/)
+      .filter((w) => w.length >= 4 && !["with", "from", "that", "this", "than"].includes(w));
+  }
+  return keywords;
+}
+
+/**
+ * Check if a message text matches any of the forbidden domains.
+ * Uses keyword heuristic — conservative (exclude if uncertain).
+ */
+function matchesForbiddenDomain(text, forbiddenDomains, domainKeywords) {
+  if (forbiddenDomains.length === 0) return false;
+  const lower = text.toLowerCase();
+  for (const domain of forbiddenDomains) {
+    const keywords = domainKeywords[domain] || [];
+    // If 2+ keywords from a domain match, consider it a match
+    let hits = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) hits++;
+      if (hits >= 2) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Load conversation history, filtered by disclosure boundaries.
+ */
+function loadConversationHistory(senderSlug, channelId, budgetTokens, forbiddenDomains) {
+  const maxChars = budgetTokens * CHARS_PER_TOKEN;
+  const entries = [];
+  const today = new Date().toISOString().split("T")[0];
+
+  // Candidate directories to scan
+  const candidateDirs = [];
+  if (channelId) candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", channelId));
+  if (senderSlug) {
+    candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", `dm-${senderSlug}`));
+    candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", senderSlug));
+  }
+
+  for (const dir of candidateDirs) {
+    try {
+      const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .sort()
+        .reverse()
+        .slice(0, 3); // Today + yesterday + day before
+
+      for (const file of files) {
+        try {
+          const content = readFileSync(join(dir, file), "utf-8").trim();
+          if (!content) continue;
+          for (const line of content.split("\n").filter(Boolean)) {
+            try { entries.push(JSON.parse(line)); } catch {}
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  if (entries.length === 0) return null;
+
+  // Deduplicate by timestamp
+  const seen = new Set();
+  const unique = entries.filter((e) => {
+    const key = `${e.ts || e.received_at || ""}:${e.from || ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  // Sort chronologically
+  unique.sort((a, b) => {
+    const tsA = a.ts || a.received_at || "";
+    const tsB = b.ts || b.received_at || "";
+    return tsA.localeCompare(tsB);
+  });
+
+  // Filter by disclosure boundaries
+  const domainKeywords = buildDomainKeywords();
+  const filtered = unique.filter((e) => {
+    const text = e.content || e.text || "";
+    return !matchesForbiddenDomain(text, forbiddenDomains, domainKeywords);
+  });
+
+  // Format and truncate to budget (most recent first for truncation)
+  const lines = [];
+  let totalChars = 0;
+
+  // Take from end (most recent) to respect budget
+  for (let i = filtered.length - 1; i >= 0; i--) {
+    const e = filtered[i];
+    const from = e.from || e.user_name || e.sender || "unknown";
+    const text = (e.content || e.text || "").substring(0, 300);
+    const ts = e.received_at || e.ts || "";
+    const responded = e.response_sent ? " [Responded]" : "";
+    const line = `[${ts}] ${from}: ${text}${responded}`;
+
+    if (totalChars + line.length > maxChars) break;
+    lines.unshift(line); // Prepend to maintain chronological order
+    totalChars += line.length;
+  }
+
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+
+/**
+ * Load active session state from active.json.
+ */
+function loadActiveSessions(budgetTokens) {
+  const activePath = join(SESSION_DIR, "active.json");
+  try {
+    const raw = readFileSync(activePath, "utf-8");
+    const sessions = JSON.parse(raw);
+    const entries = Object.entries(sessions);
+    if (entries.length === 0) return null;
+
+    const lines = entries.map(([id, s]) => {
+      const age = Math.round((Date.now() - (s.startTime || Date.now())) / 60000);
+      return `- [${id}] ${s.summary || "unknown task"} (${s.model || "sonnet"}, ${s.sender || "system"}, started ${age}m ago)`;
+    });
+
+    return lines.join("\n");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load recent sent-message registry entries for a specific channel.
+ */
+function loadSentRegistry(channelId, budgetTokens) {
+  if (!channelId) return null;
+  const registryPath = join(SESSION_DIR, "sent-registry.jsonl");
+  try {
+    const raw = readFileSync(registryPath, "utf-8").trim();
+    if (!raw) return null;
+    const lines = raw.split("\n").filter(Boolean);
+    const entries = lines
+      .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean)
+      .filter((e) => e.channel === channelId);
+
+    if (entries.length === 0) return null;
+
+    // Take last 20 entries for this channel
+    const recent = entries.slice(-20);
+    const formatted = recent.map((e) =>
+      `[${e.timestamp}] (${e.type}) ${e.textPreview || "(no preview)"}`
+    );
+    return formatted.join("\n");
+  } catch {
+    return null;
+  }
+}
+```
+
+- [ ] **Step 4: Run all context compiler tests**
+
+```bash
+node --test scripts/daemon/test-context-compiler.mjs
+```
+
+Expected: All 7 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add scripts/daemon/context-compiler.mjs scripts/daemon/test-context-compiler.mjs
+git commit -m "feat: context compiler with disclosure boundary filtering
+
+Pre-compiles sender profile, conversation history, active sessions,
+and sent-message registry into a single context block. Filters history
+entries by information barrier domains. Adaptive token budget: 12K for
+critical/high, 8K for normal, 4K for low priority."
+```
+
+---
+
+## Task 4: Integrate Session Locks into Daemon
+
+**Files:**
+- Modify: `scripts/daemon/sophie-daemon.mjs`
+
+- [ ] **Step 1: Read the current file**
+
+Read `scripts/daemon/sophie-daemon.mjs` to confirm current line numbers.
+
+- [ ] **Step 2: Add session-lock imports, replace in-memory dedup**
+
+Replace the dedup-related code. Make these changes to `sophie-daemon.mjs`:
+
+**Add import** (after the existing imports at line 35):
+
+```javascript
+import { acquireLock, updateLock, scanStaleLocks } from "./session-lock.mjs";
+```
+
+**Remove** these lines entirely:
+- Line 44: `const DEDUP_WINDOW = 5 * 60 * 1000;`
+- Line 46: `const recentlyProcessed = new Map();`
+- Lines 71-83: The entire `isDuplicate` function and `cleanDedup` function
+
+**Replace the poll loop filter** (line 101):
+
+Old:
+```javascript
+const newItems = result.items.filter((item) => !isDuplicate(item.id || item.raw_ref));
+```
+
+New:
+```javascript
+const newItems = result.items.filter((item) => {
+  const itemId = item.id || item.raw_ref || `${svc.name}-${Date.now()}`;
+  const lock = acquireLock(itemId, {
+    sender: item.sender || "unknown",
+    channel: item.channel || item.channel_id || "unknown",
+  });
+  return lock.acquired;
+});
+```
+
+**Remove the `cleanDedup()` call** (line 121):
+
+Old:
+```javascript
+cleanDedup();
+```
+
+Remove this line entirely.
+
+**Add stale lock scan on startup** in `main()` (after emergency stop check, around line 332):
+
+```javascript
+// Clear orphaned locks from prior crashes
+const staleCleared = scanStaleLocks();
+if (staleCleared > 0) {
+  console.log(`[daemon] Cleared ${staleCleared} stale session locks`);
+}
+```
+
+- [ ] **Step 3: Update holding message to set lock flag**
+
+In `processItem()`, after the holding message is sent (around line 180), add lock update:
+
+Old:
+```javascript
+const holdResult = await sendHoldingMessage(item, classResult);
+holdingText = holdResult.sent ? holdResult.holdingText : null;
+```
+
+New:
+```javascript
+const holdResult = await sendHoldingMessage(item, classResult);
+holdingText = holdResult.sent ? holdResult.holdingText : null;
+if (holdResult.sent) {
+  const lockItemId = item.id || item.raw_ref || `${service}-${Date.now()}`;
+  updateLock(lockItemId, { holdingSent: true });
+}
+```
+
+- [ ] **Step 4: Verify daemon module loads without errors**
+
+```bash
+node -e "import('./scripts/daemon/sophie-daemon.mjs').catch(e => { console.error(e.message); process.exit(1); })"
+```
+
+Expected: May fail due to missing env vars, but should NOT fail on import errors. If it errors on missing poller modules or env vars, that's expected — the structural changes are correct.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add scripts/daemon/sophie-daemon.mjs
+git commit -m "refactor: replace in-memory dedup with file-based session locks
+
+Remove recentlyProcessed Map and isDuplicate(). Use acquireLock() for
+atomic item claim. Set holdingSent flag when holding message is sent.
+Scan and clear stale locks on daemon startup."
+```
+
+---
+
+## Task 5: Integrate Session Locks into Dispatcher
+
+**Files:**
+- Modify: `scripts/daemon/dispatcher.mjs`
+
+- [ ] **Step 1: Read the current file**
+
+Read `scripts/daemon/dispatcher.mjs` to confirm current line numbers.
+
+- [ ] **Step 2: Add imports and fix backlogKey**
+
+Add import at top (after existing imports):
+
+```javascript
+import { releaseLock, readLock } from "./session-lock.mjs";
+import { readFileSync as _readFileSync, writeFileSync as _writeFileSync, renameSync } from "fs";
+```
+
+**Stabilise `backlogKey()`** (replace lines 94-96):
+
+Old:
+```javascript
+function backlogKey(item) {
+  return item.title || item.id || item.summary || JSON.stringify(item).substring(0, 100);
+}
+```
+
+New:
+```javascript
+function backlogKey(item) {
+  return item.id || item.title || item.summary || JSON.stringify(item).substring(0, 100);
+}
+```
+
+- [ ] **Step 3: Write active.json on session spawn/close**
+
+Add helper functions after the existing `logSession` function:
+
+```javascript
+const ACTIVE_PATH = join(SOPHIE_AI_DIR, "state", "sessions", "active.json");
+
+function writeActiveSession(sessionId, entry) {
+  try {
+    let active = {};
+    try { active = JSON.parse(_readFileSync(ACTIVE_PATH, "utf-8")); } catch {}
+    active[sessionId] = {
+      sender: entry.item?.sender || null,
+      channel: entry.item?.channel || entry.item?.channel_id || null,
+      summary: entry.classResult?.summary || "unknown",
+      model: entry.classResult?.model || "sonnet",
+      startTime: Date.now(),
+      source: entry.source,
+    };
+    const tmpPath = ACTIVE_PATH + ".tmp";
+    _writeFileSync(tmpPath, JSON.stringify(active, null, 2));
+    renameSync(tmpPath, ACTIVE_PATH);
+  } catch (err) {
+    console.warn(`[dispatcher] Failed to write active.json: ${err.message}`);
+  }
+}
+
+function removeActiveSession(sessionId) {
+  try {
+    let active = {};
+    try { active = JSON.parse(_readFileSync(ACTIVE_PATH, "utf-8")); } catch {}
+    delete active[sessionId];
+    const tmpPath = ACTIVE_PATH + ".tmp";
+    _writeFileSync(tmpPath, JSON.stringify(active, null, 2));
+    renameSync(tmpPath, ACTIVE_PATH);
+  } catch (err) {
+    console.warn(`[dispatcher] Failed to update active.json: ${err.message}`);
+  }
+}
+```
+
+**In `spawnSession()`**, after `activeSessions.set(sessionId, ...)` (around line 208), add:
+
+```javascript
+writeActiveSession(sessionId, entry);
+```
+
+**In the `proc.on("close")` handler** (around line 224), after `activeSessions.delete(sessionId)`, add:
+
+```javascript
+removeActiveSession(sessionId);
+
+// Release item lock
+const itemId = item.id || item.raw_ref || item.title;
+if (itemId) releaseLock(itemId);
+```
+
+- [ ] **Step 4: Verify module loads**
+
+```bash
+node -e "import('./scripts/daemon/dispatcher.mjs').catch(e => { console.error(e.message); process.exit(1); })"
+```
+
+Expected: No import errors.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add scripts/daemon/dispatcher.mjs
+git commit -m "refactor: write active.json and release locks on session lifecycle
+
+Dispatcher now writes/removes entries from state/sessions/active.json
+on session spawn/close (atomic via tmp+rename). Releases item locks
+on session completion. Stabilise backlogKey to prefer item.id."
+```
+
+---
+
+## Task 6: Integrate Context Compiler into Prompt Builder
+
+**Files:**
+- Modify: `scripts/daemon/prompt-builder.mjs`
+
+- [ ] **Step 1: Read the current file**
+
+Read `scripts/daemon/prompt-builder.mjs` to confirm current state.
+
+- [ ] **Step 2: Add context compiler import and feature flag**
+
+Add import at top (after existing imports):
+
+```javascript
+import { compileContext } from "./context-compiler.mjs";
+```
+
+- [ ] **Step 3: Replace conversation history and profile instruction with compiled context**
+
+In `buildPrompt()`, replace sections 4 and 6 with the compiled context.
+
+**Remove the MAX_HISTORY_LINES constant** (line 12):
+
+```javascript
+// Delete: const MAX_HISTORY_LINES = 30;
+```
+
+**Remove the `loadConversationHistory()` function** (lines 148-216 approximately) entirely — this logic now lives in context-compiler.mjs.
+
+**Remove the `extractChannelId()` helper** (lines 221-233) — also moved to context-compiler.
+
+**Replace section 4 (conversation history) and section 6 (profile instruction)** in `buildPrompt()`.
+
+Old section 4 (around lines 369-376):
+```javascript
+  // 4. Conversation history (so the session has prior context)
+  if (type === "inbox" && item) {
+    const history = loadConversationHistory(item);
+    if (history) {
+      parts.push(history);
+      parts.push("");
+    }
+  }
+```
+
+Old section 6 (around lines 382-387):
+```javascript
+  // 6. User profile lookup (for inbox items with a sender)
+  if (type === "inbox" && item.sender) {
+    const profileName = item.sender.replace(/\s+/g, "-").toLowerCase();
+    parts.push(`Before responding, read memory/profiles/users/${profileName}.yaml for sender preferences, standing instructions, and relationship context. If the file does not exist, proceed without it.`);
+    parts.push("");
+  }
+```
+
+Replace BOTH with a single compiled context block (insert after section 3, before section 5):
+
+```javascript
+  // 4. Compiled context (profile + history + disclosure boundaries + active sessions + sent messages)
+  if (process.env.DAEMON_CONTEXT_COMPILER === "1" && (type === "inbox" ? item : true)) {
+    try {
+      const { contextBlock } = await compileContext(
+        item || {},
+        classResult,
+        { type }
+      );
+      parts.push(contextBlock);
+      parts.push("");
+    } catch (err) {
+      console.error(`[prompt-builder] Context compilation failed: ${err.message}`);
+      // Fall through to legacy behaviour
+      if (type === "inbox" && item) {
+        const history = loadConversationHistoryLegacy(item);
+        if (history) { parts.push(history); parts.push(""); }
+      }
+    }
+  } else if (type === "inbox" && item) {
+    // Legacy path (feature flag off)
+    const history = loadConversationHistoryLegacy(item);
+    if (history) { parts.push(history); parts.push(""); }
+  }
+```
+
+**Keep the old `loadConversationHistory` as `loadConversationHistoryLegacy`** — rename the function (don't delete) so the feature flag fallback works:
+
+```javascript
+// Legacy — kept for feature flag fallback, will be removed after validation
+function loadConversationHistoryLegacy(item) {
+  // ... existing loadConversationHistory code unchanged ...
+}
+```
+
+Also keep `extractChannelId` renamed as `extractChannelIdLegacy` used by the legacy function. Or since context-compiler has its own, just keep the legacy version local.
+
+**Remove the old section 6 (profile instruction)** — it's now inside the compiled context block. In the legacy path, add it back:
+
+After the legacy history loading block, add:
+
+```javascript
+  // Legacy profile instruction (only when feature flag is off)
+  if (process.env.DAEMON_CONTEXT_COMPILER !== "1" && type === "inbox" && item && item.sender) {
+    const profileName = item.sender.replace(/\s+/g, "-").toLowerCase();
+    parts.push(`Before responding, read memory/profiles/users/${profileName}.yaml for sender preferences, standing instructions, and relationship context. If the file does not exist, proceed without it.`);
+    parts.push("");
+  }
+```
+
+- [ ] **Step 4: Verify module loads**
+
+```bash
+node -e "import('./scripts/daemon/prompt-builder.mjs').catch(e => { console.error(e.message); process.exit(1); })"
+```
+
+Expected: No import errors.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add scripts/daemon/prompt-builder.mjs
+git commit -m "feat: integrate context compiler into prompt builder
+
+Replace self-discovery instructions with pre-compiled context block.
+Feature-flagged via DAEMON_CONTEXT_COMPILER=1 — legacy path preserved
+as fallback. Sessions now receive rich pre-filtered context including
+profile, disclosure boundaries, history, active sessions, and sent
+messages directly in the prompt."
+```
+
+---
+
+## Task 7: Integrate Sent-Registry into Responder
+
+**Files:**
+- Modify: `scripts/daemon/responder.mjs`
+
+- [ ] **Step 1: Read the current file**
+
+Read `scripts/daemon/responder.mjs` to confirm current state.
+
+- [ ] **Step 2: Add session-lock imports**
+
+Add after existing imports:
+
+```javascript
+import { checkRecentlySent, registerSent } from "./session-lock.mjs";
+```
+
+- [ ] **Step 3: Add dedup check and registration to `sendQuickResponse`**
+
+In `sendQuickResponse()`, after the validation check and before `sendSlackMessage()`:
+
+Find the section (around line 396):
+```javascript
+if (item.service === "slack") {
+  const channel = resolveSlackChannel(item);
+  if (channel) {
+```
+
+Replace with:
+```javascript
+if (item.service === "slack") {
+  const channel = resolveSlackChannel(item);
+  if (channel) {
+    // Check sent-message registry for duplicates
+    const dupCheck = checkRecentlySent(channel, item.thread_id || null, "quick_reply");
+    if (!dupCheck.allowed) {
+      console.log(`[responder] Quick reply blocked by sent-registry: ${dupCheck.reason}`);
+      logResponse({ type: "quick_response_dedup_blocked", sender: item.sender, reason: dupCheck.reason });
+      return { sent: false, text: null, blocked: true, reason: dupCheck.reason };
+    }
+```
+
+After the successful `sendSlackMessage()` call and before `sendResult = { sent: true, ... }`, add:
+
+```javascript
+        registerSent(channel, item.thread_id || null, "quick_reply", "quick-responder", text.substring(0, 100));
+```
+
+- [ ] **Step 4: Add dedup check and registration to `sendHoldingMessage`**
+
+In `sendHoldingMessage()`, same pattern. After `const channel = resolveSlackChannel(item);`:
+
+```javascript
+    if (channel) {
+      // Check sent-message registry for duplicates
+      const dupCheck = checkRecentlySent(channel, item.thread_id || null, "holding");
+      if (!dupCheck.allowed) {
+        console.log(`[responder] Holding message blocked by sent-registry: ${dupCheck.reason}`);
+        logResponse({ type: "holding_dedup_blocked", sender: item.sender, reason: dupCheck.reason });
+        return { sent: false, holdingText: null, blocked: true, reason: dupCheck.reason };
+      }
+```
+
+After successful `sendSlackMessage()`:
+
+```javascript
+        registerSent(channel, item.thread_id || null, "holding", "quick-responder", text.substring(0, 100));
+```
+
+- [ ] **Step 5: Verify module loads**
+
+```bash
+node -e "import('./scripts/daemon/responder.mjs').catch(e => { console.error(e.message); process.exit(1); })"
+```
+
+Expected: No import errors.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add scripts/daemon/responder.mjs
+git commit -m "feat: add sent-message registry checks to responder
+
+Quick replies and holding messages now check the sent-registry before
+sending and register after successful send. Prevents duplicate messages
+even when upstream dedup fails."
+```
+
+---
+
+## Task 8: Integration Test
+
+**Files:**
+- Create: `scripts/daemon/test-integration.mjs`
+
+- [ ] **Step 1: Write integration tests**
+
+Create `scripts/daemon/test-integration.mjs`:
+
+```javascript
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+const TEST_DIR = join(import.meta.dirname, "../../.test-integration");
+process.env.__TEST_SESSION_DIR = join(TEST_DIR, "state", "sessions");
+process.env.__TEST_SOPHIE_DIR = TEST_DIR;
+
+function setupTestEnv() {
+  mkdirSync(join(TEST_DIR, "state", "sessions", "locks"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "profiles", "users"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-test-user"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "policies"), { recursive: true });
+  writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), "{}");
+
+  writeFileSync(join(TEST_DIR, "policies", "information-barriers.yaml"), `domains:
+  adaptic-internal-legal:
+    description: "Adaptic legal strategy, GC advice, privilege-protected"
+    default_sensitivity: high
+  rollup-strategy:
+    description: "Project Aether M&A targets, deal terms, pipeline"
+    default_sensitivity: critical
+  public:
+    description: "Published information, press, website"
+    default_sensitivity: none
+`);
+}
+
+function cleanTestEnv() {
+  rmSync(TEST_DIR, { recursive: true, force: true });
+}
+
+describe("Integration: lock → compile → prompt pipeline", () => {
+  beforeEach(setupTestEnv);
+  afterEach(cleanTestEnv);
+
+  it("acquireLock prevents duplicate processing of same item", async () => {
+    const { acquireLock, releaseLock } = await import("./session-lock.mjs");
+
+    const first = acquireLock("slack-C001-12345", { sender: "Test", channel: "C001" });
+    assert.equal(first.acquired, true);
+
+    const second = acquireLock("slack-C001-12345", { sender: "Test", channel: "C001" });
+    assert.equal(second.acquired, false);
+
+    releaseLock("slack-C001-12345");
+  });
+
+  it("sent-registry prevents duplicate sends across quick-reply and holding paths", async () => {
+    const { registerSent, checkRecentlySent } = await import("./session-lock.mjs");
+
+    // Holding message sent
+    registerSent("C001", "12345.6789", "holding", "s-1", "Looking into this now");
+
+    // Quick reply to same channel+thread should still be allowed (different type)
+    const quickCheck = checkRecentlySent("C001", "12345.6789", "quick_reply");
+    assert.equal(quickCheck.allowed, true);
+
+    // Another holding to same channel+thread should be blocked
+    const holdCheck = checkRecentlySent("C001", "12345.6789", "holding");
+    assert.equal(holdCheck.allowed, false);
+  });
+
+  it("context compiler respects disclosure boundaries end-to-end", async () => {
+    // Create a profile with restrictions
+    writeFileSync(
+      join(TEST_DIR, "memory", "profiles", "users", "test-user.yaml"),
+      `name: Test User\ninformation_boundaries:\n  excluded_domains:\n    - rollup-strategy\n`
+    );
+
+    // Create history with mixed content
+    const today = new Date().toISOString().split("T")[0];
+    writeFileSync(
+      join(TEST_DIR, "memory", "interactions", "slack", "dm-test-user", `${today}.jsonl`),
+      [
+        JSON.stringify({ ts: "100", from: "test-user", content: "What is the status?", received_at: "2026-04-06T10:00:00Z" }),
+        JSON.stringify({ ts: "101", from: "sophie", content: "Project Aether deal terms are looking good", received_at: "2026-04-06T10:01:00Z" }),
+        JSON.stringify({ ts: "102", from: "sophie", content: "The public website update is live", received_at: "2026-04-06T10:02:00Z" }),
+      ].join("\n") + "\n"
+    );
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const { contextBlock } = await compileContext(
+      { sender: "Test User", channel: "D001", channel_id: "D001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+
+    // Public content should be included
+    assert.ok(contextBlock.includes("website update is live"));
+    // Rollup content should be filtered
+    assert.ok(!contextBlock.includes("Aether deal terms"));
+    // Should have disclosure boundaries
+    assert.ok(contextBlock.includes("DO NOT mention"));
+  });
+
+  it("active sessions are visible in compiled context", async () => {
+    writeFileSync(
+      join(TEST_DIR, "state", "sessions", "active.json"),
+      JSON.stringify({
+        "s-999": {
+          sender: "Alice",
+          channel: "C002",
+          summary: "Preparing board pack",
+          model: "opus",
+          startTime: Date.now() - 120000,
+        },
+      })
+    );
+
+    const { compileContext } = await import("./context-compiler.mjs");
+    const { contextBlock } = await compileContext(
+      { sender: "Test", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+
+    assert.ok(contextBlock.includes("Preparing board pack"));
+    assert.ok(contextBlock.includes("Active Sessions"));
+  });
+});
+```
+
+- [ ] **Step 2: Run integration tests**
+
+```bash
+node --test scripts/daemon/test-integration.mjs
+```
+
+Expected: All 4 tests pass.
+
+- [ ] **Step 3: Run all test files together**
+
+```bash
+node --test scripts/daemon/test-session-lock.mjs scripts/daemon/test-context-compiler.mjs scripts/daemon/test-integration.mjs
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add scripts/daemon/test-integration.mjs
+git commit -m "test: integration tests for session lock + context compiler pipeline
+
+Covers: duplicate lock prevention, sent-registry cross-path dedup,
+disclosure boundary filtering end-to-end, active session visibility."
+```
+
+---
+
+## Task 9: Feature Flag and .env Update
+
+**Files:**
+- Modify: `.env` (or `.env.example` if it exists)
+- Modify: `config/environment.yaml` (if feature flags live there)
+
+- [ ] **Step 1: Add feature flag to .env**
+
+Add the following line to `.env`:
+
+```
+DAEMON_CONTEXT_COMPILER=1
+```
+
+- [ ] **Step 2: Add npm test script**
+
+Add to `package.json` scripts:
+
+```json
+"test:daemon": "node --test scripts/daemon/test-session-lock.mjs scripts/daemon/test-context-compiler.mjs scripts/daemon/test-integration.mjs"
+```
+
+- [ ] **Step 3: Verify all tests pass with feature flag**
+
+```bash
+DAEMON_CONTEXT_COMPILER=1 npm run test:daemon
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add package.json .env
+git commit -m "feat: enable context compiler feature flag and add test script
+
+Set DAEMON_CONTEXT_COMPILER=1 to activate the new context compilation
+pipeline. Add npm run test:daemon for running all daemon tests."
+```
+
+---
+
+## Task 10: Add .gitignore Entries and Final Cleanup
+
+**Files:**
+- Modify: `.gitignore`
+- Create: `state/sessions/locks/.gitkeep`
+
+- [ ] **Step 1: Verify .gitignore has the right entries**
+
+Ensure `.gitignore` contains:
+
+```
+# Session state (ephemeral)
+state/sessions/locks/*.lock
+state/sessions/sent-registry.jsonl
+state/sessions/active.json.tmp
+
+# Test directories
+.test-session-locks/
+.test-context-compiler/
+.test-integration/
+```
+
+- [ ] **Step 2: Run full test suite one final time**
+
+```bash
+npm run test:daemon
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add .gitignore state/sessions/locks/.gitkeep
+git commit -m "chore: gitignore ephemeral session state and test directories"
+```
+
+---
+
+## Summary
+
+| Task | What it builds | Key files |
+|------|---------------|-----------|
+| 1 | Directory structure | `state/sessions/` |
+| 2 | Session lock module + tests | `session-lock.mjs`, `test-session-lock.mjs` |
+| 3 | Context compiler + tests | `context-compiler.mjs`, `test-context-compiler.mjs` |
+| 4 | Daemon lock integration | `sophie-daemon.mjs` |
+| 5 | Dispatcher active.json + lock release | `dispatcher.mjs` |
+| 6 | Prompt builder context injection | `prompt-builder.mjs` |
+| 7 | Responder sent-registry integration | `responder.mjs` |
+| 8 | Integration tests | `test-integration.mjs` |
+| 9 | Feature flag + test script | `.env`, `package.json` |
+| 10 | Gitignore + cleanup | `.gitignore` |