@adaptic/maestro 1.0.0

package/docs/superpowers/specs/2026-04-05-reactive-daemon-design.md

@@ -0,0 +1,237 @@
+# Reactive Event-Driven Daemon — Design Spec
+
+## Summary
+
+Replace the 3-stage serial pipeline (poller → inbox processor → backlog executor) with a single persistent Node.js daemon that detects messages, classifies them via Haiku API, and immediately spawns dedicated `claude --print` sessions per item with up to 10 parallel sessions.
+
+**Target latency:** CEO DM → response in under 2 minutes (down from 14-64 min).
+
+## Architecture
+
+```
+Sophie Daemon (always running, KeepAlive via launchd)
+  │
+  ├── Poll Loop (every 30s)
+  │   ├── Slack (channels, DMs, threads)
+  │   ├── Gmail (inbox scan)
+  │   └── Calendar (event changes)
+  │
+  ├── Classifier (Haiku API, ~0.5-1s per item)
+  │   ├── Input: sender, channel, content, context
+  │   ├── Output: priority, action, model, summary
+  │   └── Fallback: OpenAI gpt-4o-mini if Anthropic fails
+  │
+  ├── Dispatcher (up to 10 parallel claude --print sessions)
+  │   ├── Priority Queue (CEO/urgent — preempts)
+  │   ├── Normal Queue (FIFO)
+  │   ├── Model routing: opus for complex, sonnet for routine
+  │   └── Timeouts: 5 min sonnet, 15 min opus
+  │
+  └── Backlog Sweep (every 2 min)
+      └── Scans state/queues/ for stale/overdue items
+```
+
+## Classification Layer
+
+Every incoming message gets a fast LLM classification via direct Anthropic API call (Claude Haiku). No CLI startup overhead.
+
+### Classifier Input
+
+```json
+{
+  "sender": "mehran-granfar",
+  "sender_privilege": "ceo",
+  "channel": "dm",
+  "service": "slack",
+  "content": "Can you send the board resolution to Nima?",
+  "is_reply": false,
+  "thread_context": null
+}
+```
+
+### Classifier Output
+
+```json
+{
+  "priority": "critical",
+  "action": "respond",
+  "model": "opus",
+  "summary": "CEO requesting board resolution sent to Nima",
+  "category": "action_required"
+}
+```
+
+### Priority Levels
+
+- **critical**: CEO directives, regulatory deadlines, urgent tags → immediate slot
+- **high**: Leadership requests, time-sensitive items → next available slot
+- **normal**: Routine correspondence, FYI items → queued FIFO
+- **low/ignore**: CI notifications, spam, automated alerts → logged, no session spawned
+
+### Model Routing
+
+- **opus**: CEO directives, strategic decisions, drafting in Mehran's voice, regulatory, complex reasoning, research, document drafting
+- **sonnet**: Routine follow-ups, status updates, simple email responses, acknowledgements, queue management, archiving
+
+### Fallback Chain
+
+1. Anthropic API (Claude Haiku) — primary
+2. OpenAI API (gpt-4o-mini) — fallback if Anthropic errors
+3. Rule-based classification — fallback if both APIs fail (pattern match on sender privilege + keywords)
+
+## Dispatcher
+
+### Concurrency Model
+
+- **Max parallel sessions**: 10
+- **Reserved priority slots**: 2 (if all 10 busy and critical item arrives, it gets next free slot — max ~30s wait given sonnet sessions are fast)
+- **Session timeouts**: 5 min for sonnet, 15 min for opus — killed if exceeded
+- **Queue behavior**: When session completes, daemon immediately dispatches next queued item
+
+### Session Spawning
+
+Each item spawns a dedicated `claude --print` session via Node.js `child_process.spawn`:
+
+```javascript
+const session = spawn(CLAUDE_BIN, [
+  '--print',
+  '--dangerously-skip-permissions',
+  '--model', classResult.model,  // 'sonnet' or 'opus'
+  prompt
+], {
+  cwd: SOPHIE_AI_DIR,
+  env: { ...process.env },
+  timeout: classResult.model === 'opus' ? 900000 : 300000
+});
+```
+
+### Prompt Building
+
+Each dispatched session gets a focused prompt built from:
+1. The CLAUDE.md identity preamble (cached, not re-read each time)
+2. The specific item context (sender, content, thread history)
+3. Action instructions based on classifier output
+4. Relevant user profile (`memory/profiles/users/{sender}.yaml`)
+5. Queue context if it's a backlog item
+
+### Backlog Sweep
+
+Every 2 minutes, the daemon:
+1. Reads `state/queues/*.yaml` for items with status `open` or `in_progress`
+2. Filters to actionable items (not blocked, not awaiting reply unless stale)
+3. Sorts by priority and SLA deadline
+4. Dispatches top items to available session slots (respects concurrency cap)
+
+## What Gets Replaced
+
+| Old Component | Replacement |
+|---|---|
+| `scripts/poller/index.mjs` (60s launchd timer) | Daemon internal poll loop (30s) |
+| `ai.adaptic.sophie-poller` plist | `ai.adaptic.sophie-daemon` plist (KeepAlive) |
+| `schedules/triggers/inbox-processor.md` via launchd | Classification + dispatch in daemon |
+| `schedules/triggers/backlog-executor.md` via launchd | 2-min backlog sweep in daemon |
+| `ai.adaptic.sophie-inbox-processor` plist | Removed |
+| `ai.adaptic.sophie-backlog-executor` plist | Removed |
+| `scripts/poller/trigger.mjs` (file-based priority) | Direct session spawn on priority detection |
+
+### Kept As-Is
+
+- All weekly/daily launchd triggers (meeting prep, midday sweep, strategic memo, etc.)
+- Poller functions (`slack-poller.mjs`, `gmail-poller.mjs`, `calendar-poller.mjs`) — reused by daemon
+- Queue file format and state directory structure
+- All governance, audit, and logging infrastructure
+
+## File Structure
+
+```
+scripts/
+  daemon/
+    sophie-daemon.mjs      # Main persistent process — poll loop, orchestration
+    classifier.mjs          # LLM classification via Haiku API + OpenAI fallback
+    dispatcher.mjs          # Session spawning, concurrency management, queue
+    prompt-builder.mjs      # Builds claude --print prompts per item type
+    health.mjs              # Health check endpoint + metrics logging
+  poller/                   # Kept — polling functions reused by daemon
+    slack-poller.mjs
+    gmail-poller.mjs
+    calendar-poller.mjs
+    utils.mjs
+```
+
+## Launchd Configuration
+
+```xml
+<key>Label</key>
+<string>ai.adaptic.sophie-daemon</string>
+<key>ProgramArguments</key>
+<array>
+    <string>/opt/homebrew/bin/node</string>
+    <string>/Users/sophie/sophie-ai/scripts/daemon/sophie-daemon.mjs</string>
+</array>
+<key>KeepAlive</key>
+<true/>
+<key>RunAtLoad</key>
+<true/>
+<key>ThrottleInterval</key>
+<integer>5</integer>
+```
+
+`KeepAlive: true` means launchd auto-restarts if the daemon crashes. `ThrottleInterval: 5` prevents rapid restart loops.
+
+## Environment Variables Required
+
+```bash
+# .env
+ANTHROPIC_API_KEY=sk-ant-...     # For Haiku classification + direct API calls
+OPENAI_API_KEY=sk-...            # Fallback classification
+SLACK_USER_TOKEN=xoxp-...       # Slack polling
+SLACK_BOT_TOKEN=xoxb-...        # Slack posting
+GMAIL_CLIENT_ID=...             # Gmail OAuth
+GMAIL_CLIENT_SECRET=...
+GMAIL_REFRESH_TOKEN=...
+```
+
+## Dependencies (new)
+
+```json
+{
+  "@anthropic-ai/sdk": "^0.52.0",
+  "openai": "^4.0.0"
+}
+```
+
+## Expected Performance
+
+| Metric | Old | New |
+|---|---|---|
+| CEO DM → response | 14-64 min | ~1-2 min |
+| Routine email → action | 14-64 min | ~30-60s |
+| Ignored items (spam, CI) | 14-64 min to classify | ~1s (no session) |
+| Parallel throughput | 1 item at a time | Up to 10 simultaneous |
+| Empty cycle overhead | 15-17s (CLI boot) | 0s (daemon running) |
+| Classification latency | N/A (was part of inbox processor) | 0.5-1s (Haiku API) |
+
+## Logging & Audit
+
+- Every classification result logged to `logs/daemon/{date}-classifications.jsonl`
+- Every session spawn logged to `logs/daemon/{date}-sessions.jsonl`
+- Session stdout/stderr captured to `logs/daemon/sessions/{session-id}.log`
+- Health metrics written to `state/dashboards/daemon-health.yaml` every 60s
+- All existing audit infrastructure (pre-send hooks, action logging) unchanged
+
+## Error Handling
+
+- **Classifier API failure**: Fall through Anthropic → OpenAI → rule-based
+- **Session crash**: Log error, update queue item status to `error`, retry once
+- **Rate limit hit**: Queue items, log warning, resume when limit resets
+- **Daemon crash**: launchd KeepAlive auto-restarts within 5s
+- **Stuck session**: Timeout kills it (5m sonnet / 15m opus), item re-queued
+
+## Migration Path
+
+1. Build daemon alongside existing infrastructure
+2. Test daemon with poller disabled (daemon handles polling)
+3. Unload old poller, inbox-processor, backlog-executor plists
+4. Load daemon plist
+5. Monitor for 24h
+6. Remove old plist templates if stable

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

@@ -0,0 +1,369 @@
+# Session Context & Dedup Overhaul — Design Spec
+
+**Date:** 2026-04-06
+**Status:** Approved
+**Author:** Sophie Nguyen (with Mehran)
+**Triggered by:** Observed symptoms — duplicate responses to single messages, sub-sessions lacking conversational context
+
+---
+
+## Problem Statement
+
+Sophie's daemon spawns independent `claude --print` sessions to handle incoming messages and backlog items. Two critical deficiencies:
+
+1. **Duplicate responses:** The same inbound message triggers multiple response sessions (holding message + full session + sometimes a re-dispatched session), resulting in the sender receiving 2-3 similar replies.
+2. **Context blindness:** Full sessions receive instructions to "go read memory files" but lack pre-compiled conversational context. They respond without the benefit of prior exchanges, user profiles, or awareness of what other sessions are doing concurrently.
+
+### Root Causes Identified
+
+| # | Cause | Symptom | Location |
+|---|-------|---------|----------|
+| 1 | Race condition in in-memory dedup (`recentlyProcessed` Map) — non-atomic check-and-dispatch | Duplicate responses | `sophie-daemon.mjs:71-76` |
+| 2 | No inbox-level session tracking (backlog has `activeBacklogKeys`, inbox has nothing) | Duplicate responses after 5-min dedup window expires | `dispatcher.mjs:23-25` |
+| 3 | Full sessions told to self-discover context files rather than receiving pre-compiled context | Missing conversational context | `prompt-builder.mjs:385` |
+| 4 | Inconsistent history loading (responder=15 entries, prompt-builder=30 lines) | Divergent context between quick-reply and full-session paths | `responder.mjs:178` vs `prompt-builder.mjs:12` |
+| 5 | Unstable backlog dedup key (uses `title \|\| id \|\| summary`) | Backlog items spawn multiple sessions | `dispatcher.mjs:94-96` |
+
+---
+
+## Architecture Overview
+
+Three new modules, four modified modules.
+
+### New Modules
+
+| Module | Purpose |
+|--------|---------|
+| `scripts/daemon/session-lock.mjs` | File-based session locks + sent-message registry. Replaces in-memory dedup. |
+| `scripts/daemon/context-compiler.mjs` | Pre-compiles all relevant context into a single block injected into session prompts at dispatch time. |
+| `state/sessions/` (directory) | Persistent session state: locks, active sessions, sent-message registry. |
+
+### Modified Modules
+
+| Module | Change |
+|--------|--------|
+| `scripts/daemon/sophie-daemon.mjs` | Replace in-memory dedup with file-based locks |
+| `scripts/daemon/dispatcher.mjs` | Write/read `active.json`, unified lock system for inbox + backlog |
+| `scripts/daemon/prompt-builder.mjs` | Replace self-discovery instructions with pre-compiled context block |
+| `scripts/daemon/responder.mjs` | Register all sent messages in sent-registry; check before sending |
+
+### Key Architectural Shift
+
+**Before:** Sessions receive instructions to navigate the filesystem and discover context at runtime.
+**After:** Context is compiled before dispatch and injected as structured data in the prompt. Sessions receive rich, pre-filtered context as data — not navigation instructions.
+
+---
+
+## Module 1: Session Lock System (`session-lock.mjs`)
+
+### Lock Lifecycle
+
+```
+Message arrives → acquireLock(itemId) → returns { acquired: true/false, lockData? }
+  ├─ Lock file written: state/sessions/locks/{itemId}.lock
+  │   Contains: { sessionId, itemId, channel, sender, acquiredAt, holdingSent, substantiveSent }
+  ├─ If lock already exists and < 15 min old → acquired: false (skip)
+  └─ If lock exists but > 15 min old → stale, overwrite (session probably died)
+
+Session completes → releaseLock(itemId)
+  └─ Lock file deleted
+
+Daemon restart → scanStaleLocks() on startup
+  └─ Clear any locks older than OPUS_TIMEOUT (15 min)
+```
+
+### Item ID Sanitisation
+
+Item IDs (e.g., `slack:D099N1JGKRQ:1775331885.690669`) contain characters invalid in filenames. Sanitise by replacing all non-alphanumeric characters with hyphens: `slack-D099N1JGKRQ-1775331885-690669.lock`. Use a shared `sanitiseItemId()` function exported from `session-lock.mjs`.
+
+### Lock File Atomicity
+
+Lock files use `writeFileSync` with the `wx` flag (exclusive create) for atomicity on macOS. If two processes race to create the same lock, only one succeeds; the other gets an `EEXIST` error and knows the item is already being handled.
+
+### Lock File Schema
+
+```json
+{
+  "sessionId": "s-1775451995191-1",
+  "itemId": "slack:D099N1JGKRQ:1775331885.690669",
+  "channel": "D099N1JGKRQ",
+  "sender": "Mehran Granfar",
+  "acquiredAt": "2026-04-06T10:00:00.000Z",
+  "holdingSent": false,
+  "substantiveSent": false
+}
+```
+
+### Exported Functions
+
+```javascript
+acquireLock(itemId, metadata)    // → { acquired: boolean, existing?: lockData }
+releaseLock(itemId)              // → void
+updateLock(itemId, updates)      // → void (e.g., set holdingSent: true)
+readLock(itemId)                 // → lockData | null
+scanStaleLocks()                 // → number of stale locks cleared
+```
+
+### Sent-Message Registry
+
+Append-only JSONL file at `state/sessions/sent-registry.jsonl`.
+
+```javascript
+checkRecentlySent(channel, threadTs, type) // → { allowed: boolean, reason?: string }
+registerSent(channel, threadTs, type, sessionId, textPreview)  // → void
+```
+
+**Registry entry schema:**
+```json
+{
+  "timestamp": "2026-04-06T10:00:05.000Z",
+  "channel": "D099N1JGKRQ",
+  "threadTs": "1775331885.690669",
+  "type": "holding",
+  "sessionId": "s-1775451995191-1",
+  "textPreview": "Got it — let me look into this now."
+}
+```
+
+**Dedup rules:**
+- Same channel + thread + type within 5 minutes → BLOCK
+- Same channel + type "substantive" within 2 minutes (even different threads) → BLOCK (prevents rapid-fire to same person)
+- Registry rotated daily (files older than 2 days auto-deleted)
+
+---
+
+## Module 2: Context Compiler (`context-compiler.mjs`)
+
+### Compilation Pipeline
+
+```
+compileContext(item, classResult, options) → { contextBlock: string, tokenEstimate: number }
+```
+
+**Step 1 — Determine Token Budget:**
+
+| Priority | Model | Budget |
+|----------|-------|--------|
+| critical / high | opus | ~12K tokens (~48K chars) |
+| normal | sonnet | ~8K tokens (~32K chars) |
+| low | sonnet | ~4K tokens (~16K chars) |
+
+**Step 2 — Load User Profile** (~500 tokens):
+- Read `memory/profiles/users/{sender-slug}.yaml`
+- Extract: standing instructions, communication preferences, authority level, relationship context
+- If file missing, produce a minimal "unknown sender" block
+
+**Step 3 — Load Disclosure Boundaries** (~300 tokens):
+- Read recipient profile → extract `allowed_domains[]`
+- Read `policies/information-barriers.yaml` → map domain sensitivities
+- Compute: `forbidden_domains[]`, `explicit_restrictions[]`
+- Output as a "DISCLOSURE BOUNDARIES" block with explicit "DO NOT mention" list
+- For unknown senders: default to `public` domain only
+
+**Step 4 — Load Conversation History** (60% of remaining budget):
+- Scan `memory/interactions/slack/{channel-id}/` and `dm-{sender-slug}/`
+- Read today + yesterday + day-before JSONL files
+- Sort chronologically, deduplicate by timestamp
+- **FILTER:** Remove entries tagged with or matching `forbidden_domains` from step 3
+  - Domain matching uses keyword heuristic: match terms from `information-barriers.yaml` domain descriptions against message content
+  - This is a best-effort upstream filter — `validate-outbound.py` + `disclosure_assessment.py` remain the final gate
+- Truncate to budget (most recent messages prioritised)
+- Format as timestamped conversation log
+
+**Step 5 — Load Active Session State** (~300 tokens):
+- Read `state/sessions/active.json`
+- Format: list of currently in-flight sessions with sender, channel, summary, duration
+- Purpose: session knows what other sessions are doing to avoid duplicate work
+
+**Step 6 — Load Sent-Message Registry** (~500 tokens):
+- Read `state/sessions/sent-registry.jsonl` (last 20 entries for this channel/sender)
+- Format: timestamped list of what Sophie already said to this sender today
+- Purpose: session knows what's already been communicated and avoids repeating it
+
+**Step 7 — Assemble:**
+
+```
+--- COMPILED CONTEXT (do not repeat verbatim) ---
+
+## Sender Profile
+[compact profile — name, role, preferences, standing instructions]
+
+## Disclosure Boundaries
+ALLOWED domains: [list]. DO NOT mention: [explicit restrictions with reasoning].
+
+## Conversation History (most recent last)
+[timestamped messages, filtered by disclosure boundaries]
+
+## Active Sessions
+[in-flight session summaries — what's being worked on right now]
+
+## Already Sent
+[messages Sophie already sent to this sender/channel today with timestamps and previews]
+
+--- END CONTEXT ---
+```
+
+### Graceful Degradation
+
+Every step handles missing files gracefully. If no profile exists, that section is omitted. If no interaction history, that section says "No prior conversation history found." The compiler never throws — it always produces a valid (possibly minimal) context block.
+
+---
+
+## Module 3: Integration Changes
+
+### `sophie-daemon.mjs`
+
+**Remove:**
+- `recentlyProcessed` Map (line 46)
+- `isDuplicate()` function (lines 71-76)
+- `cleanDedup()` function (lines 78-83)
+- `cleanDedup()` call in poll loop (line 121)
+
+**Add:**
+- Import `{ acquireLock, releaseLock, scanStaleLocks }` from `./session-lock.mjs`
+- On startup (`main()`): call `scanStaleLocks()` to clear orphaned locks
+- In poll loop: replace `isDuplicate(item.id)` with `acquireLock(itemId, { sender, channel })` — if not acquired, skip
+- After holding message sent: call `updateLock(itemId, { holdingSent: true })`
+- Lock release happens in dispatcher on session close (not in daemon directly)
+
+### `dispatcher.mjs`
+
+**Remove:**
+- Asymmetry between inbox and backlog dedup (inbox now uses same lock system)
+
+**Add:**
+- Import `{ releaseLock, readLock }` from `./session-lock.mjs`
+- On `spawnSession()`: write session entry to `state/sessions/active.json`
+  - Schema: `{ [sessionId]: { item, sender, channel, summary, model, startTime, source } }`
+  - Use atomic write (write to temp file, rename)
+- On session close (`proc.on("close")`): remove from `active.json`, call `releaseLock(itemId)`
+- Stabilise `backlogKey()`: use `item.id` as primary key, fall back to `item.title` only if no `id`
+
+### `prompt-builder.mjs`
+
+**Remove:**
+- `loadConversationHistory()` function (lines 148-216) — moved to context-compiler
+- "Before responding, read memory/profiles/users/..." instruction (line 385) — replaced by compiled context
+- `MAX_HISTORY_LINES` constant (line 12) — budget now managed by context-compiler
+
+**Add:**
+- Import `{ compileContext }` from `./context-compiler.mjs`
+- In `buildPrompt()`: call `const { contextBlock } = await compileContext(item, classResult, options)`
+- Insert `contextBlock` between item context (section 3) and action instructions (section 5)
+- Feature flag: if `process.env.DAEMON_CONTEXT_COMPILER !== "1"`, use existing behaviour
+
+### `responder.mjs`
+
+**Add:**
+- Import `{ checkRecentlySent, registerSent }` from `./session-lock.mjs`
+- In `sendQuickResponse()` before `sendSlackMessage()`: call `checkRecentlySent(channel, threadTs, "quick_reply")` — if blocked, return `{ sent: false, reason: "duplicate_prevented" }`
+- In `sendQuickResponse()` after successful send: call `registerSent(channel, threadTs, "quick_reply", "quick-responder", text.substring(0, 100))`
+- Same pattern for `sendHoldingMessage()` with type `"holding"`
+
+### Directory Structure
+
+```
+state/sessions/
+├── active.json            # Currently running sessions (atomically overwritten)
+├── locks/                 # One .lock file per in-flight item
+│   └── {sanitised-itemId}.lock
+└── sent-registry.jsonl    # Append-only log of all sent messages (rotated daily)
+```
+
+---
+
+## Information Barrier Integration
+
+### Compile-Time Filtering (Layer 1)
+
+The context compiler reads the recipient's profile to determine allowed domains, then filters conversation history entries that match forbidden domains before including them in the prompt. This means the session never sees the sensitive information in the first place.
+
+**Domain matching heuristic:**
+- Each domain in `information-barriers.yaml` has a description with key terms
+- History entries are scanned for these terms (case-insensitive substring match)
+- Entries matching any forbidden domain are excluded from the compiled context
+- Conservative: if uncertain, exclude rather than include
+
+### Prompt-Time Boundaries (Layer 2)
+
+The compiled context includes an explicit "DISCLOSURE BOUNDARIES" block:
+
+```
+## Disclosure Boundaries
+ALLOWED domains: adaptic-operations, ftlab-operations, engineering, public.
+DO NOT mention or reference:
+- Rollup strategy, acquisition targets, deal terms, Project Aether
+- Cap table details, runway figures, fundraising pipeline
+- Legal privilege, GC advice, internal legal strategy
+- Board deliberations, draft resolutions
+- Individual compensation, performance reviews
+```
+
+This serves as a direct instruction to the session, providing defense in depth even if the history filtering misses something.
+
+### Existing Final Gate (Unchanged)
+
+`validate-outbound.py` + `disclosure_assessment.py` remain the final gate before any message is actually sent. The context compiler is upstream filtering to reduce risk — not a replacement for the send-time validation.
+
+---
+
+## Testing Strategy
+
+### Unit Tests: `session-lock.mjs`
+
+- `acquireLock()` succeeds on first call, returns `{ acquired: true }`
+- `acquireLock()` for same item returns `{ acquired: false }` (duplicate prevention)
+- `acquireLock()` succeeds after `releaseLock()`
+- Stale lock (>15 min) is overwritten by new `acquireLock()`
+- `scanStaleLocks()` clears locks older than 15 minutes
+- `checkRecentlySent()` blocks same channel+thread+type within 5 min
+- `checkRecentlySent()` allows after 5 min window
+- `registerSent()` appends to JSONL correctly
+
+### Unit Tests: `context-compiler.mjs`
+
+- Token budget adapts: critical=12K, normal=8K, low=4K
+- User profile loaded and formatted correctly
+- Missing profile produces minimal "unknown sender" block
+- Disclosure boundaries computed from recipient profile + policy
+- History entries matching forbidden domains are excluded
+- Active session state loaded from `active.json`
+- Sent-registry entries for same sender/channel included
+- Graceful degradation: no crashes when any source file is missing
+- Output format has correct section headers
+
+### Integration Tests
+
+- Full pipeline: poll → lock → classify → compile context → build prompt → dispatch
+- Prompt contains compiled context block (not "go read this file")
+- Holding message registers in sent-registry
+- Full session prompt includes "holding already sent" + sent-registry data
+- Duplicate message to same channel/thread blocked by registry
+- Feature flag: `DAEMON_CONTEXT_COMPILER=0` uses old behaviour
+
+### Information Barrier Tests
+
+- Shayan (FTLab partner) context excludes `rollup-strategy` and `adaptic-internal-legal` entries
+- CEO (Mehran) context includes all domains
+- Unknown sender gets `public` domain only
+- Disclosure boundaries block appears in compiled context with correct restrictions
+
+---
+
+## Rollout
+
+1. Ship behind feature flag: `DAEMON_CONTEXT_COMPILER=1` in `.env`
+2. When flag is off: existing behaviour unchanged (prompt-builder works as today)
+3. When flag is on: new pipeline active (context-compiler + session-locks)
+4. Monitor via `logs/daemon/` for 24 hours
+5. Compare: response quality, dedup effectiveness, session duration, token usage
+6. Remove flag once validated
+
+## What Stays Unchanged
+
+- Quick-reply path (responder.mjs) still uses direct Anthropic API with its own context loading — it already works well
+- `validate-outbound.py` remains the final send gate
+- Interaction logging (`responder.mjs` `logInteraction()`) unchanged — feeds future context compilation
+- Classifier (`classifier.mjs`) unchanged
+- Backlog sweep logic unchanged (benefits from better lock system)
+- Poller modules unchanged