@cohortapp/agent-sdk 2.3.0

package/scripts/daemon/health.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+// Health — periodic health metrics and status logging
+
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { getStatus } from "./dispatcher.mjs";
+
+const AGENT_REPO_DIR = process.env.AGENT_DIR || join(new URL(".", import.meta.url).pathname, "../..");
+
+let stats = {
+  daemon_start: new Date().toISOString(),
+  polls_total: 0,
+  items_detected: 0,
+  items_classified: 0,
+  sessions_spawned: 0,
+  sessions_completed: 0,
+  sessions_failed: 0,
+  classifications_failed: 0,
+  last_poll: null,
+  last_item: null,
+};
+
+export function recordPoll(itemCount) {
+  stats.polls_total++;
+  stats.items_detected += itemCount;
+  stats.last_poll = new Date().toISOString();
+  if (itemCount > 0) stats.last_item = stats.last_poll;
+}
+
+export function recordClassification(success) {
+  if (success) stats.items_classified++;
+  else stats.classifications_failed++;
+}
+
+export function recordSession(completed, success) {
+  if (!completed) {
+    stats.sessions_spawned++;
+  } else if (success) {
+    stats.sessions_completed++;
+  } else {
+    stats.sessions_failed++;
+  }
+}
+
+export function writeHealthDashboard() {
+  const dispatcher = getStatus();
+  const dashboard = {
+    updated: new Date().toISOString(),
+    uptime_s: Math.floor((Date.now() - new Date(stats.daemon_start).getTime()) / 1000),
+    ...stats,
+    dispatcher,
+  };
+
+  const dir = join(AGENT_REPO_DIR, "state", "dashboards");
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, "daemon-health.yaml");
+
+  const yaml = Object.entries(dashboard)
+    .map(([k, v]) => {
+      if (typeof v === "object" && v !== null) {
+        return `${k}:\n${JSON.stringify(v, null, 2).split("\n").map(l => `  ${l}`).join("\n")}`;
+      }
+      return `${k}: ${v}`;
+    })
+    .join("\n");
+
+  writeFileSync(path, yaml + "\n");
+}
+
+export function getStats() {
+  return { ...stats };
+}

package/scripts/daemon/inbox-deferral.mjs

@@ -0,0 +1,210 @@
+/**
+ * Maestro — Inbox deferral utilities
+ *
+ * When the dispatcher hits a thread/channel-level dedup lock, the
+ * incoming message used to be marked `.processed` and dropped on the
+ * floor. That meant rapid-fire DMs (or thread bursts) silently lost
+ * every message after the first.
+ *
+ * This module replaces that with a defer-then-promote pattern:
+ *
+ *   markDeferred(item, service, agentRoot)
+ *     Renames the inbox file from `<name>` to `<name>.deferred`.
+ *     The daemon's inbox scanner skips `.deferred` files, so the
+ *     message is parked but not lost.
+ *
+ *   promoteDeferred(channel, agentRoot)
+ *     Called from the dispatcher's session-close release path. Finds
+ *     every `.deferred` file in any service inbox dir whose body
+ *     references `channel`. If exactly one is found, renames it back
+ *     to its original name (next poll picks it up). If N>1 are found,
+ *     keeps only the LATEST (by timestamp), promotes that one, and
+ *     marks the others `.processed-bundled` for the audit trail —
+ *     the latest item's `thread_context` already contains the prior
+ *     messages as conversation history, so Claude sees everything
+ *     and can compose a single coherent reply.
+ *
+ * The file format is the YAML emitted by the slack/gmail/calendar
+ * pollers (a flat top-level object with quoted scalar fields, plus an
+ * optional block-scalar body). We deliberately avoid pulling in a YAML
+ * parser — extraction of the COLUMN-0 top-level `channel_id:` and
+ * `timestamp:` fields is sufficient for the routing decision and keeps
+ * this module dependency-free. Extraction is anchored to top-level keys so
+ * an indented `channel_id:`/`timestamp:` inside a message body block scalar
+ * can never be mistaken for the real field (audit L7).
+ */
+
+import { readdirSync, readFileSync, renameSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const SERVICE_DIRS = ["slack", "gmail", "calendar", "internal", "sms", "whatsapp"];
+
+/**
+ * Rename a live inbox file to its `.deferred` suffix so the scanner
+ * skips it until the channel/thread lock releases.
+ *
+ * Mirrors markProcessed's file-matching strategy (id or raw_ref
+ * substring) so we hit the same file that markProcessed would have.
+ *
+ * Idempotent: if the file is already `.deferred` or `.processed`, no-op.
+ *
+ * @returns {number} number of files renamed (usually 1, occasionally 0
+ *                   for backlog items with no inbox file)
+ */
+export function markDeferred(item, service, agentRoot) {
+  if (!item || !service || !agentRoot) return 0;
+  const inboxDir = join(agentRoot, "state", "inbox", service);
+  if (!existsSync(inboxDir)) return 0;
+  let renamed = 0;
+  try {
+    const needle = item.id || item.raw_ref;
+    if (!needle) return 0;
+    const files = readdirSync(inboxDir).filter(
+      (f) => !f.endsWith(".processed") &&
+             !f.endsWith(".deferred") &&
+             !f.endsWith(".processed-bundled") &&
+             (f.includes(item.id || "") || f.includes(item.raw_ref || ""))
+    );
+    for (const file of files) {
+      renameSync(join(inboxDir, file), join(inboxDir, `${file}.deferred`));
+      renamed++;
+    }
+  } catch {
+    // Inbox dir may not exist for non-poller-backed items (e.g. backlog).
+  }
+  return renamed;
+}
+
+// Escape regex metacharacters in an interpolated field name so a field like
+// `a.b` can't be read as a wildcard (audit L7).
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Extract a TOP-LEVEL scalar value from a poller-written inbox YAML file.
+ * Returns `null` if the field is absent.
+ *
+ * We only need this for `channel_id` (routing) and `timestamp`
+ * (latest-wins selection) — both are written as quoted single-line
+ * scalars by every poller.
+ *
+ * Audit L7: the previous regex used `^\s*field:` with the `m` flag, so any
+ * INDENTED line inside a block scalar (e.g. a message body that itself
+ * contains `  channel_id: D-OTHER` or `  timestamp: ...`) could match and be
+ * mistaken for the real top-level field — mis-routing the promote to the
+ * wrong channel. We now scan only the column-0 top-level region: keys with NO
+ * leading whitespace, stopping at the first block/indented region. A YAML
+ * block scalar (`key: |` / `key: >`) introduces an indented body, so once we
+ * see one we skip its indented continuation lines instead of matching inside
+ * them. The interpolated field name is regex-escaped.
+ */
+function readScalar(body, field) {
+  if (typeof body !== "string") return null;
+  const key = escapeRegExp(field);
+  // Top-level key: starts at column 0 (no indentation), value on same line.
+  // Capture group handles optional double-quotes around the value.
+  const topLevel = new RegExp(`^${key}\\s*:\\s*"?([^"\\n]*?)"?\\s*$`);
+  // A column-0 line that opens a block scalar or a nested mapping/sequence —
+  // its indented continuation lines are NOT top-level and must be skipped.
+  const opensBlock = /^[^\s:][^:]*:\s*(?:[|>][+-]?\d*)?\s*$/;
+
+  const lines = body.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Skip indented (non-top-level) lines entirely — they belong to a block
+    // scalar body or a nested structure, never a top-level scalar.
+    if (/^\s/.test(line)) continue;
+    if (line.trim() === "") continue;
+    const m = line.match(topLevel);
+    if (m) return m[1].trim();
+    // If this top-level line opens a block/nested region, the following
+    // indented lines are its body — they're skipped by the `^\s` guard above,
+    // so no extra bookkeeping is needed here. (Documented for clarity.)
+    void opensBlock;
+  }
+  return null;
+}
+
+/**
+ * Promote every `.deferred` item targeting `channel` back into the
+ * live inbox. Bundles bursts: if multiple deferred items exist for
+ * the same channel, only the latest is re-queued (the others are
+ * marked `.processed-bundled` since their content is already present
+ * in the latest item's thread_context).
+ *
+ * Called from the dispatcher's session-close path, AFTER the channel
+ * lock has been released, so the next poll cycle is free to re-acquire.
+ *
+ * @returns {{promoted: number, bundled: number, service: string|null}}
+ */
+export function promoteDeferred(channel, agentRoot) {
+  const result = { promoted: 0, bundled: 0, service: null };
+  if (!channel || !agentRoot) return result;
+
+  for (const service of SERVICE_DIRS) {
+    const inboxDir = join(agentRoot, "state", "inbox", service);
+    if (!existsSync(inboxDir)) continue;
+
+    let deferredFiles;
+    try {
+      deferredFiles = readdirSync(inboxDir).filter((f) => f.endsWith(".deferred"));
+    } catch {
+      continue;
+    }
+    if (deferredFiles.length === 0) continue;
+
+    // Filter to items whose body references this channel. Reading
+    // every .deferred file is cheap (a handful at most) — we stay
+    // dependency-free by regex-scanning rather than parsing YAML.
+    const matches = [];
+    for (const file of deferredFiles) {
+      let body;
+      try {
+        body = readFileSync(join(inboxDir, file), "utf-8");
+      } catch {
+        continue;
+      }
+      const fileChannel = readScalar(body, "channel_id");
+      if (fileChannel !== channel) continue;
+      matches.push({
+        file,
+        timestamp: readScalar(body, "timestamp") || "",
+      });
+    }
+    if (matches.length === 0) continue;
+
+    // Latest-wins: lex-sort ISO timestamps, take the most recent.
+    matches.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const latest = matches[matches.length - 1];
+    const older = matches.slice(0, -1);
+
+    // Promote the latest back to live inbox.
+    try {
+      const live = latest.file.replace(/\.deferred$/, "");
+      renameSync(join(inboxDir, latest.file), join(inboxDir, live));
+      result.promoted++;
+      result.service = service;
+    } catch {
+      // If the rename failed (race with another process), leave it
+      // as .deferred — the next session-close will retry.
+    }
+
+    // Mark older bursts as bundled — their content is already part of
+    // the latest item's thread_context, so they don't need their own
+    // session, but we preserve the file for audit.
+    for (const m of older) {
+      try {
+        renameSync(
+          join(inboxDir, m.file),
+          join(inboxDir, m.file.replace(/\.deferred$/, ".processed-bundled"))
+        );
+        result.bundled++;
+      } catch {
+        // Best-effort; missing file is fine.
+      }
+    }
+  }
+
+  return result;
+}

package/scripts/daemon/inbox-deferral.test.mjs

@@ -0,0 +1,242 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { markDeferred, promoteDeferred } from "./inbox-deferral.mjs";
+
+function makeAgentRoot() {
+  const root = mkdtempSync(join(tmpdir(), "maestro-deferral-"));
+  mkdirSync(join(root, "state", "inbox", "slack"), { recursive: true });
+  return root;
+}
+
+function writeInboxItem(root, name, { channel_id, timestamp, id = "test-id" }) {
+  const body = [
+    `id: "${id}"`,
+    `service: "slack"`,
+    `channel_id: "${channel_id}"`,
+    `timestamp: "${timestamp}"`,
+    `content: |`,
+    `  body`,
+    "",
+  ].join("\n");
+  writeFileSync(join(root, "state", "inbox", "slack", name), body);
+}
+
+test("markDeferred renames live file to .deferred", () => {
+  const root = makeAgentRoot();
+  try {
+    writeInboxItem(root, "msg-A.yaml", {
+      channel_id: "D001",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "msg-A",
+    });
+    const n = markDeferred({ id: "msg-A" }, "slack", root);
+    assert.equal(n, 1);
+    const files = readdirSync(join(root, "state", "inbox", "slack"));
+    assert.deepEqual(files, ["msg-A.yaml.deferred"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("markDeferred is idempotent — already-deferred files are skipped", () => {
+  const root = makeAgentRoot();
+  try {
+    writeInboxItem(root, "msg-B.yaml.deferred", {
+      channel_id: "D001",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "msg-B",
+    });
+    const n = markDeferred({ id: "msg-B" }, "slack", root);
+    assert.equal(n, 0);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("markDeferred is no-op when item has no matching file (e.g. backlog)", () => {
+  const root = makeAgentRoot();
+  try {
+    const n = markDeferred({ id: "no-such-id" }, "slack", root);
+    assert.equal(n, 0);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("promoteDeferred with single item: renames back to live", () => {
+  const root = makeAgentRoot();
+  try {
+    writeInboxItem(root, "msg-C.yaml.deferred", {
+      channel_id: "D099N1JEA10",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "msg-C",
+    });
+    const r = promoteDeferred("D099N1JEA10", root);
+    assert.equal(r.promoted, 1);
+    assert.equal(r.bundled, 0);
+    assert.equal(r.service, "slack");
+    const files = readdirSync(join(root, "state", "inbox", "slack"));
+    assert.deepEqual(files, ["msg-C.yaml"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("promoteDeferred with multiple items: keeps latest, bundles rest", () => {
+  const root = makeAgentRoot();
+  try {
+    writeInboxItem(root, "msg-1.yaml.deferred", {
+      channel_id: "D001",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "msg-1",
+    });
+    writeInboxItem(root, "msg-2.yaml.deferred", {
+      channel_id: "D001",
+      timestamp: "2026-05-13T00:01:00Z",
+      id: "msg-2",
+    });
+    writeInboxItem(root, "msg-3.yaml.deferred", {
+      channel_id: "D001",
+      timestamp: "2026-05-13T00:02:00Z",
+      id: "msg-3",
+    });
+    const r = promoteDeferred("D001", root);
+    assert.equal(r.promoted, 1);
+    assert.equal(r.bundled, 2);
+    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
+    assert.deepEqual(files, [
+      "msg-1.yaml.processed-bundled",
+      "msg-2.yaml.processed-bundled",
+      "msg-3.yaml", // latest survives as live
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("promoteDeferred ignores items in other channels", () => {
+  const root = makeAgentRoot();
+  try {
+    writeInboxItem(root, "for-A.yaml.deferred", {
+      channel_id: "D-A",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "for-A",
+    });
+    writeInboxItem(root, "for-B.yaml.deferred", {
+      channel_id: "D-B",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "for-B",
+    });
+    const r = promoteDeferred("D-A", root);
+    assert.equal(r.promoted, 1);
+    assert.equal(r.bundled, 0);
+    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
+    assert.deepEqual(files, ["for-A.yaml", "for-B.yaml.deferred"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("promoteDeferred no-op when nothing to promote", () => {
+  const root = makeAgentRoot();
+  try {
+    const r = promoteDeferred("D999", root);
+    assert.equal(r.promoted, 0);
+    assert.equal(r.bundled, 0);
+    assert.equal(r.service, null);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Audit L7 — block-scalar body must not be mis-parsed for routing fields
+// ---------------------------------------------------------------------------
+
+/**
+ * Write an inbox item whose `content` block scalar body itself contains lines
+ * that look like top-level `channel_id:` / `timestamp:` keys. A naive
+ * `^\s*field:` regex would match the INDENTED body line and mis-route.
+ */
+function writeInboxItemWithTrickyBody(root, name, { channel_id, timestamp, id, bodyChannel, bodyTimestamp }) {
+  const lines = [
+    `id: "${id}"`,
+    `service: "slack"`,
+    `channel_id: "${channel_id}"`,
+    `timestamp: "${timestamp}"`,
+    `content: |`,
+    `  Hi team — quoting an old config below:`,
+    `  channel_id: ${bodyChannel}`,
+    `  timestamp: ${bodyTimestamp}`,
+    `  please review.`,
+    "",
+  ];
+  writeFileSync(join(root, "state", "inbox", "slack", name), lines.join("\n"));
+}
+
+test("L7: body line `channel_id:` in a block scalar does not mis-route", () => {
+  const root = makeAgentRoot();
+  try {
+    // Real top-level channel is D-REAL. The body mentions D-EVIL on an
+    // indented `channel_id:` line — promote must target D-REAL only.
+    writeInboxItemWithTrickyBody(root, "tricky.yaml.deferred", {
+      channel_id: "D-REAL",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "tricky",
+      bodyChannel: "D-EVIL",
+      bodyTimestamp: "1999-01-01T00:00:00Z",
+    });
+
+    // Promoting the body's channel must find NOTHING (the body line is not a
+    // real top-level field).
+    const evil = promoteDeferred("D-EVIL", root);
+    assert.equal(evil.promoted, 0, "must not match the indented body channel_id");
+    assert.equal(evil.bundled, 0);
+
+    // Promoting the genuine top-level channel must succeed.
+    const real = promoteDeferred("D-REAL", root);
+    assert.equal(real.promoted, 1, "real top-level channel_id must match");
+    assert.equal(real.bundled, 0);
+    const files = readdirSync(join(root, "state", "inbox", "slack"));
+    assert.deepEqual(files, ["tricky.yaml"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("L7: latest-wins uses top-level timestamp, not a body `timestamp:` line", () => {
+  const root = makeAgentRoot();
+  try {
+    // Two items in the same channel. Item B is genuinely later by its
+    // top-level timestamp, but its block-scalar body contains an EARLY
+    // `timestamp:` line. A naive parser could read the body line, pick A as
+    // "latest" and bundle B. Correct behaviour: B wins (later top-level ts).
+    writeInboxItem(root, "A.yaml.deferred", {
+      channel_id: "D-TS",
+      timestamp: "2026-05-13T00:00:00Z",
+      id: "A",
+    });
+    writeInboxItemWithTrickyBody(root, "B.yaml.deferred", {
+      channel_id: "D-TS",
+      timestamp: "2026-05-13T09:00:00Z", // genuinely later
+      id: "B",
+      bodyChannel: "D-TS",
+      bodyTimestamp: "2000-01-01T00:00:00Z", // decoy early ts in the body
+    });
+
+    const r = promoteDeferred("D-TS", root);
+    assert.equal(r.promoted, 1);
+    assert.equal(r.bundled, 1);
+    const files = readdirSync(join(root, "state", "inbox", "slack")).sort();
+    assert.deepEqual(files, [
+      "A.yaml.processed-bundled", // earlier item bundled
+      "B.yaml", // later top-level timestamp survives as live
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/scripts/daemon/integration.test.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * test-integration.mjs — End-to-end integration tests for session lock + context compiler pipeline
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEST_DIR = join(__dirname, "../../.test-integration");
+
+// Set env BEFORE importing modules. context-compiler.mjs reads its repo root
+// from __TEST_AGENT_DIR (the legacy __TEST_SOPHIE_DIR name was never honoured by
+// the module, so the disclosure-boundary fixtures were written here but read
+// from the real repo — the cause of the end-to-end failure). Set both: the
+// session-lock module reads __TEST_SESSION_DIR; the compiler reads
+// __TEST_AGENT_DIR + __TEST_SESSION_DIR.
+process.env.__TEST_SESSION_DIR = join(TEST_DIR, "state", "sessions");
+process.env.__TEST_AGENT_DIR = TEST_DIR;
+process.env.__TEST_SOPHIE_DIR = TEST_DIR; // kept for any legacy reader; harmless
+
+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:
+  internal-legal:
+    description: "Northwind legal strategy, GC advice, privilege-protected"
+    default_sensitivity: high
+  strategic-initiative:
+    description: "the strategic initiative 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 });
+}
+
+const { acquireLock, releaseLock, registerSent, checkRecentlySent } = await import("./session-lock.mjs");
+const { compileContext } = await import("./context-compiler.mjs");
+
+// ─── Integration tests ─────────────────────────────────────────────────
+
+describe("Integration: lock → compile → prompt pipeline", () => {
+  beforeEach(setupTestEnv);
+  afterEach(cleanTestEnv);
+
+  it("acquireLock prevents duplicate processing of same item", () => {
+    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", () => {
+    // Holding message sent
+    registerSent("C001", "12345.6789", "holding", "s-1", "Looking into this now");
+
+    // A quick reply to the SAME channel+thread is blocked by the thread-cooldown
+    // rule (Rule 2): once anything has been sent to a thread, the whole thread
+    // cools down so the quick-reply path and the full-session path can't both
+    // fire into the same thread. (The original assertion expected the different
+    // type to be allowed — that predated Rule 2 and was stale; Rule 2 is the
+    // whole point of this test, "prevents duplicate sends across paths".)
+    const quickCheck = checkRecentlySent("C001", "12345.6789", "quick_reply");
+    assert.equal(quickCheck.allowed, false);
+    assert.match(quickCheck.reason, /thread cooldown/);
+
+    // Another holding to same channel+thread is likewise blocked.
+    const holdCheck = checkRecentlySent("C001", "12345.6789", "holding");
+    assert.equal(holdCheck.allowed, false);
+
+    // But a different, untouched thread is still free to receive a quick reply —
+    // the cooldown is scoped to the thread, not the whole channel (non-DM).
+    const otherThread = checkRecentlySent("C001", "99999.0000", "quick_reply");
+    assert.equal(otherThread.allowed, true);
+  });
+
+  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    - strategic-initiative\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: "robin", content: "the strategic initiative deal terms are looking good", received_at: "2026-04-06T10:01:00Z" }),
+        JSON.stringify({ ts: "102", from: "robin", content: "The public website update is live", received_at: "2026-04-06T10:02:00Z" }),
+      ].join("\n") + "\n"
+    );
+
+    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"));
+    // Strategic-initiative content should be filtered. (The old assertion
+    // checked for "Aether deal terms" — absent from the fixture — so it was a
+    // tautology; assert against the actual excluded fixture text.)
+    assert.ok(!contextBlock.includes("strategic initiative 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 { 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"));
+  });
+});