@cohortapp/agent-sdk 2.3.0

package/scripts/daemon/agent-daemon.mjs

@@ -0,0 +1,989 @@
+#!/usr/bin/env node
+// =============================================================================
+// Agent Daemon — Reactive event-driven message processor
+// =============================================================================
+//
+// Persistent Node.js process that:
+//   1. Polls Slack/Gmail/Calendar every 30s
+//   2. Classifies each item via Haiku API (~0.5-1s)
+//   3. Spawns dedicated claude --print sessions per item (up to 10 parallel)
+//   4. Sweeps backlog queues every 2 min for stale items
+//
+// Replaces: poller + inbox-processor + backlog-executor (3-stage pipeline)
+// Target: CEO DM → response in under 2 minutes
+//
+// Run: node scripts/daemon/<agent>-daemon.mjs (e.g. ravi-daemon.mjs)
+// Install: launchd plist with KeepAlive: true
+// =============================================================================
+
+import { resolve, join } from "path";
+import { readdirSync, readFileSync, renameSync, mkdirSync, appendFileSync, writeFileSync, unlinkSync } from "fs";
+
+// Load .env before anything else. dotenv is present on every agent machine but
+// is not a packaged dependency, so we import it dynamically + best-effort: this
+// keeps production behaviour identical (the .env is loaded exactly as before)
+// while letting the module be imported in CI/dev (no dotenv) for unit testing.
+const AGENT_REPO_DIR = process.env.AGENT_DIR || resolve(new URL(".", import.meta.url).pathname, "../..");
+try {
+  const { config } = await import("dotenv");
+  config({ path: join(AGENT_REPO_DIR, ".env") });
+} catch { /* dotenv unavailable (CI/dev) — env already provided by the parent */ }
+
+// Load agent identity (canonical SOT) so filters can match the running
+// agent's own name/slack-id rather than a hardcoded one.
+let _agent = null;
+function loadAgent() {
+  if (_agent) return _agent;
+  try {
+    _agent = JSON.parse(readFileSync(join(AGENT_REPO_DIR, "config/agent.json"), "utf-8"));
+  } catch {
+    _agent = { firstName: "Agent", lastName: "", slackMemberId: "" };
+  }
+  return _agent;
+}
+
+import { pollSlack } from "../poller/slack-poller.mjs";
+import { pollGmail } from "../poller/gmail-poller.mjs";
+import { pollCalendar } from "../poller/calendar-poller.mjs";
+import { pollVoice } from "../poller/voice-poller.mjs";
+import { pollSecondaryGmail } from "../poller/secondary-gmail-poller.mjs";
+import { makeInboxScanPoller } from "../poller/inbox-scan-poller.mjs";
+import { existsSync as _existsSync } from "fs";
+import { isPriorityItem } from "../poller/utils.mjs";
+import { classifyItem, isDirectedAtAgent } from "./classifier.mjs";
+import { dispatch, getStatus, availableSlots, canDispatchBacklog, resetActiveSessions } from "./dispatcher.mjs";
+import { buildPrompt } from "./prompt-builder.mjs";
+import { sendQuickResponse, sendHoldingMessage, isQuickReply } from "./responder.mjs";
+import { recordPoll, recordClassification, recordSession, writeHealthDashboard } from "./health.mjs";
+import { acquireLock, releaseLock, updateLock, scanStaleLocks, acquireThreadLock, claimRequest, hasActiveClaim, sweepStaleItemClaims, sanitiseItemId } from "./session-lock.mjs";
+import { markDeferred } from "./inbox-deferral.mjs";
+import { parseQueueItems } from "../../lib/backlog.mjs";
+// Org shared-memory write-back (central store via memory.author / knowledge.append
+// RPC). After a daemon turn completes cleanly we distil a one-line record of the
+// work and land it in the org's shared, ACL'd store so the fleet's memory
+// compounds. Fail-open + best-effort — never blocks or throws into the hot path;
+// local SQLite/interaction logs remain the fail-open cache.
+import { isEnabled as orgEnabled, loadOrgConfig } from "../../lib/org/client.mjs";
+import { remember as orgRemember } from "../../lib/org/knowledge.mjs";
+import { sweepSessionOutcomes } from "./session-outcomes.mjs";
+// Observability spine (WS — diagnostics). mintTraceId + withTrace give each
+// inbound item ONE trace_id that deep callees inherit via AsyncLocalStorage;
+// emitEvent appends the canonical interaction hops (item_received → … → sent /
+// error) to logs/diagnostics. counters.bump tallies fail-opens. getHookBus()
+// is the in-process lifecycle bus we wire ONE real onGuardFail subscriber onto
+// at init so the bus is live, not dead. ALL of these are fail-open by design
+// (emitEvent/bump never throw), so this instrumentation can never take down the
+// hot inbound path it observes.
+import { mintTraceId, withTrace } from "../../lib/diagnostics/trace.mjs";
+import { emitEvent, EVENT_TYPES } from "../../lib/diagnostics/events.mjs";
+import * as counters from "../../lib/diagnostics/counters.mjs";
+import { getHookBus } from "../../lib/hooks/bus.mjs";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const POLL_INTERVAL = parseInt(process.env.DAEMON_POLL_INTERVAL || "60000", 10); // 60s (up from 30s to avoid Slack rate limits)
+// Backlog sweep cadence — bumped 2min → 10min in 1.10. The dispatcher
+// applies a per-item post-completion cooldown (4h success, 30min failure)
+// so we no longer need a tight sweep loop. Operators with high-throughput
+// queues can override via DAEMON_BACKLOG_INTERVAL.
+const BACKLOG_INTERVAL = parseInt(process.env.DAEMON_BACKLOG_INTERVAL || "600000", 10); // 10 min
+const HEALTH_INTERVAL = 60000; // 1 min
+// Note: dedup is now handled by file-based locks in session-lock.mjs
+
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+
+function logDir() {
+  const dir = join(AGENT_REPO_DIR, "logs", "daemon");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function today() {
+  return new Date().toISOString().split("T")[0];
+}
+
+function logEvent(type, entry) {
+  const path = join(logDir(), `${today()}-${type}.jsonl`);
+  appendFileSync(path, JSON.stringify({ timestamp: new Date().toISOString(), ...entry }) + "\n");
+}
+
+// ---------------------------------------------------------------------------
+// Deduplication — now handled by file-based locks in session-lock.mjs
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Poll Loop
+// ---------------------------------------------------------------------------
+
+async function poll() {
+  const services = [
+    { name: "slack", fn: pollSlack },
+    { name: "gmail", fn: pollGmail },
+    { name: "alex-gmail", fn: pollSecondaryGmail },
+    { name: "calendar", fn: pollCalendar },
+    { name: "voice", fn: pollVoice },
+  ];
+
+  // WS2: channel-bus platforms (Telegram, Baileys WhatsApp) deliver events as
+  // inbox YAML via the daemon's channel loop. They have no API poller, so a
+  // generic inbox scanner drains their items into the same pipeline. Gate on
+  // the platform's config file so we don't scan dirs for disabled channels.
+  for (const [name, gate] of [["telegram", "config/telegram.yaml"], ["whatsapp", "config/whatsapp.yaml"], ["orgmail", "config/orgmail.yaml"]]) {
+    if (_existsSync(join(AGENT_REPO_DIR, gate))) {
+      services.push({ name, fn: makeInboxScanPoller(name, { agentRoot: AGENT_REPO_DIR }) });
+    }
+  }
+
+  let totalItems = 0;
+
+  for (const svc of services) {
+    try {
+      const result = await svc.fn();
+      // Dedup by raw_ref first: the same Slack message arrives via
+      // multiple paths (channel scan, thread scan, events-server JSON)
+      // with different item IDs. Using raw_ref as the lock key ensures
+      // a single message is only processed once regardless of path.
+      const seenRefs = new Set();
+      const newItems = result.items.filter((item) => {
+        // Skip the agent's own messages — defensive check in case intake filters miss them
+        const sender = (item.sender || "").toLowerCase();
+        const me = loadAgent();
+        const myFirst = (me.firstName || "").toLowerCase();
+        const myFull = (me.fullName || "").toLowerCase().replace(/\s+/g, "-");
+        if (myFirst && (sender === myFirst || sender === myFull)) return false;
+
+        const lockKey = item.raw_ref || item.id || `${svc.name}-${Date.now()}`;
+        if (seenRefs.has(lockKey)) return false;
+        seenRefs.add(lockKey);
+        const lock = acquireLock(lockKey, {
+          sender: item.sender || "unknown",
+          channel: item.channel || item.channel_id || "unknown",
+        });
+        return lock.acquired;
+      });
+      totalItems += newItems.length;
+
+      for (const item of newItems) {
+        await processItem(item, svc.name);
+      }
+
+      if (result.errors.length > 0) {
+        console.warn(`[daemon] ${svc.name} errors:`, result.errors.slice(0, 3));
+      }
+    } catch (err) {
+      console.error(`[daemon] ${svc.name} poll failed:`, err.message);
+    }
+  }
+
+  recordPoll(totalItems);
+  if (totalItems > 0) {
+    console.log(`[daemon] Poll found ${totalItems} new items`);
+  }
+
+}
+
+// ---------------------------------------------------------------------------
+// Process a single item
+// ---------------------------------------------------------------------------
+
+/**
+ * Process a single inbound item end-to-end (classify → quick-reply or
+ * holding+session → finalize).
+ *
+ * @param {object} item   the poller inbox item
+ * @param {string} service the source service ("slack" | "gmail" | ...)
+ * @param {object} [deps]  test-only injectable collaborators. PRODUCTION PASSES
+ *   NOTHING — the defaults are the real imports, so behaviour is byte-identical.
+ *   Mirrors the existing seam idiom (setSpawnForTests / opts.runClaudeCLI). This
+ *   exists ONLY so a test can drive the REAL instrumented body (trace minting,
+ *   item_received → … → sent emission) without spawning a `claude` child.
+ *   @param {Function} [deps.classify]            override classifyItem
+ *   @param {Function} [deps.dispatch]            override dispatch
+ *   @param {Function} [deps.sendQuickResponse]   override sendQuickResponse
+ *   @param {Function} [deps.sendHoldingMessage]  override sendHoldingMessage
+ *   @param {Function} [deps.isQuickReply]        override isQuickReply
+ */
+export async function processItem(item, service, deps = {}) {
+  const itemId = item.raw_ref || item.id || `${service}-${Date.now()}`;
+
+  // Observability: mint ONE trace_id per inbound item and run the whole
+  // processing body inside withTrace so every deep callee (classifier, dispatch,
+  // responder, the spawned session's close hook) inherits the same id via
+  // AsyncLocalStorage. The id is also carried explicitly onto the item so it
+  // survives the serialized dispatch + in-flight admission (a boundary that
+  // AsyncLocalStorage cannot cross). emitEvent is fail-open — it never throws.
+  const trace_id = mintTraceId();
+  item.trace_id = trace_id;
+  return withTrace({ trace_id, span: "root" }, () => processItemTraced(item, service, itemId, trace_id, deps));
+}
+
+async function processItemTraced(item, service, itemId, trace_id, deps = {}) {
+  // Resolve collaborators: real imports by default (production), injected fakes
+  // only when a test supplies them. Names match the imported symbols 1:1.
+  const _classify = deps.classify || classifyItem;
+  const _dispatch = deps.dispatch || dispatch;
+  const _sendQuickResponse = deps.sendQuickResponse || sendQuickResponse;
+  const _sendHoldingMessage = deps.sendHoldingMessage || sendHoldingMessage;
+  const _isQuickReply = deps.isQuickReply || isQuickReply;
+
+  emitEvent({
+    type: EVENT_TYPES.ITEM_RECEIVED,
+    trace_id,
+    attrs: { item_id: itemId, service, sender: item.sender || null, kind: item.kind || "message" },
+  });
+
+  try {
+    // Enrich item with channel-type metadata for directed-message detection
+    const channelStr = (item.channel || "").toLowerCase();
+    const channelId = item.channel_id || "";
+    const isDm = channelStr.startsWith("dm/") || channelId.startsWith("D");
+    const myFirstName = loadAgent().firstName || "Agent";
+    const agentThreadRegex = new RegExp(`^${myFirstName}:`, "m");
+    const agentInThread = !!(item.thread_context && agentThreadRegex.test(item.thread_context));
+    item.is_dm = isDm;
+    item.agent_in_thread = agentInThread;
+
+    // Classify via Haiku API
+    const classResult = await _classify({
+      sender: item.sender || "unknown",
+      sender_privilege: item.sender_privilege || item.priority_signals?.from_ceo ? "ceo" : "unknown",
+      channel: item.channel || "unknown",
+      service,
+      content: item.content || item.subject || "",
+      is_reply: item.is_reply || false,
+      thread_context: item.thread_context || null,
+      subject: item.subject || "",
+      is_dm: isDm,
+      is_group: !isDm && service === "slack",
+      agent_in_thread: agentInThread,
+      kind: item.kind || "message",
+    });
+
+    recordClassification(true);
+
+    logEvent("classifications", {
+      item_id: itemId,
+      sender: item.sender,
+      service,
+      ...classResult,
+    });
+
+    console.log(`[daemon] Classified: [${classResult.priority}] ${classResult.summary} → ${classResult.model} (${classResult.action})`);
+
+    // Skip ignored items
+    if (classResult.category === "ignore" || classResult.action === "ignore") {
+      markProcessed(item, service);
+      return;
+    }
+
+    // DIRECTED-MESSAGE GATE: In channels and group chats, only respond to
+    // messages that are clearly directed at the agent. DMs always pass.
+    // This prevents the agent from inserting itself into every conversation.
+    //
+    // Two-layer check:
+    //   1. If LLM says NOT directed → verify with rules (catch missed @mentions, CEO, DMs)
+    //   2. If LLM says directed BUT it's a non-DM channel → verify with rules (catch over-eager LLM)
+    if (service === "slack") {
+      const isDm = item.is_dm || (item.channel || "").startsWith("dm/") || (item.channel_id || "").startsWith("D");
+
+      if (!classResult.directed_at_agent) {
+        // LLM says not directed — double-check with rule-based heuristics
+        // to catch clear signals the LLM may have missed (DM, CEO, @mention)
+        const ruleCheck = isDirectedAtAgent(item);
+        if (!ruleCheck) {
+          console.log(`[daemon] Directed-message filter: skipping non-directed message from ${item.sender} in ${item.channel}`);
+          logEvent("classifications", {
+            item_id: itemId,
+            sender: item.sender,
+            service,
+            skipped: true,
+            reason: "not_directed_at_agent",
+            classifier_directed: false,
+            rule_directed: false,
+            summary: classResult.summary,
+          });
+          markProcessed(item, service);
+          return;
+        }
+        // Rule-based says directed — override LLM
+        console.log(`[daemon] Directed-message override: LLM said not directed but rule-based detected direction (${item.sender} in ${item.channel})`);
+      } else if (!isDm) {
+        // LLM says directed in a channel/group — sanity-check with rules.
+        // If rule-based also agrees, proceed. If rules say no AND the message
+        // doesn't contain the agent's name, the LLM was probably over-eager.
+        const ruleCheck = isDirectedAtAgent(item);
+        const content = (item.content || "").toLowerCase();
+        const me = loadAgent();
+        const myFirst = (me.firstName || "").toLowerCase();
+        const mySlackPrefix = (me.slackMemberId || "").slice(0, 3); // e.g. "U09"
+        const mentionsAgent =
+          (myFirst && content.includes(myFirst)) ||
+          (mySlackPrefix && content.includes(`<@${mySlackPrefix}`));
+        if (!ruleCheck && !mentionsAgent) {
+          console.log(`[daemon] Directed-message filter (LLM override): LLM said directed but rules disagree for ${item.sender} in ${item.channel} — skipping`);
+          logEvent("classifications", {
+            item_id: itemId,
+            sender: item.sender,
+            service,
+            skipped: true,
+            reason: "llm_over_eager_directed",
+            classifier_directed: true,
+            rule_directed: false,
+            summary: classResult.summary,
+          });
+          markProcessed(item, service);
+          return;
+        }
+      }
+    }
+
+    // THREAD / CHANNEL DEDUP: Prevent multiple sessions from responding to the
+    // same conversation. For thread replies, lock by thread_ts. For non-threaded
+    // DMs, lock by channel_id (so rapid-fire DMs don't each spawn a session).
+    // This check runs BEFORE quick reply to prevent ALL duplicate responses.
+    {
+      const channel = item.channel_id || (item.raw_ref ? item.raw_ref.match(/slack:([^:]+):/)?.[1] : null) || item.channel;
+      const threadTs = item.thread_id || (isDm ? `dm-channel` : null);
+      if (threadTs && channel) {
+        const threadCheck = acquireThreadLock(channel, threadTs);
+        if (!threadCheck.allowed) {
+          // Defer instead of dropping: rename to .deferred so the file
+          // is preserved and re-promoted to the live inbox when the
+          // active session for this channel releases its lock. The
+          // dispatcher calls promoteDeferred() from its session-close
+          // path; the next poll cycle then picks the latest deferred
+          // item up and dispatches a single session that sees the full
+          // thread context (older bursts are bundled).
+          //
+          // We also release the per-item lock that the poll filter
+          // acquired at the top of the cycle — otherwise the next
+          // poll's acquireLock would block re-processing of this
+          // exact item after we promote it back to live.
+          const deferred = markDeferred(item, service, AGENT_REPO_DIR);
+          releaseLock(itemId);
+          console.log(`[daemon] Thread/channel dedup: deferring item from ${item.sender} — ${threadCheck.reason}${deferred ? "" : " (no inbox file to defer)"}`);
+          logEvent("classifications", {
+            item_id: itemId,
+            sender: item.sender,
+            service,
+            deferred: deferred > 0,
+            reason: `thread_dedup: ${threadCheck.reason}`,
+          });
+          return;
+        }
+      }
+    }
+
+    // REQUEST CLAIMING: For action_required items, claim the request so
+    // parallel sessions (from overlapping poll cycles or backlog sweep)
+    // don't independently process the same "email me the brief" request.
+    // Claim key: action_type + recipient channel + summary (normalized).
+    if (classResult.category === "action_required" && (classResult.action === "respond" || classResult.action === "draft" || classResult.action === "research")) {
+      const claimAttrs = {
+        recipient: item.channel_id || item.channel || item.sender || "unknown",
+        subject: classResult.summary || item.subject || "",
+        action_type: classResult.action,
+      };
+      const claim = claimRequest(claimAttrs);
+      if (!claim.claimed) {
+        console.log(`[daemon] Request claim denied for ${item.sender}: ${claim.reason}`);
+        logEvent("classifications", {
+          item_id: itemId,
+          sender: item.sender,
+          service,
+          skipped: true,
+          reason: `request_claim_denied: ${claim.reason}`,
+          summary: classResult.summary,
+        });
+        markProcessed(item, service);
+        return;
+      }
+    }
+
+    // QUICK REPLY PATH: Direct responses via API + Slack/Gmail posting.
+    // No claude --print session needed. ~4-8 seconds total.
+    if (_isQuickReply(classResult)) {
+      console.log(`[daemon] Quick reply path for ${item.sender} (${classResult.model})`);
+      const result = await _sendQuickResponse(item, classResult);
+      if (result.sent) {
+        markProcessed(item, service);
+        return;
+      }
+      // If quick reply failed to send or was blocked by validation, fall through to dispatch a full session
+      const reason = result.blocked ? `validation blocked: ${result.issues?.map(i => i.rule).join(", ")}` : "send failed";
+      console.warn(`[daemon] Quick reply not sent (${reason}), falling through to session dispatch`);
+    }
+
+    // COMPLEX WORK PATH: Send immediate holding message, then dispatch full session
+    let holdingText = null;
+    try {
+      if (classResult.action === "respond" || classResult.action === "draft" || classResult.action === "research") {
+        const holdResult = await _sendHoldingMessage(item, classResult);
+        holdingText = holdResult.sent ? holdResult.holdingText : null;
+        if (holdResult.sent) {
+          updateLock(itemId, { holdingSent: true });
+        }
+      }
+    } catch (err) {
+      console.error(`[daemon] Holding message failed (non-fatal): ${err.message}`);
+    }
+
+    // Build prompt with holding message context and dispatch
+    const prompt = await buildPrompt(item, classResult, {
+      type: "inbox",
+      holdingMessage: holdingText,
+    });
+    // F1/H2: record a DURABLE in-flight admission and DEFER markProcessed() to
+    // the dispatch onClose SUCCESS path. The previous code marked the item
+    // `.processed` immediately after this fire-and-forget dispatch — a crash
+    // before the spawned session closed lost the user's message. Now a clean
+    // close finalizes; any failure (non-zero close / spawn error) clears the
+    // admission and releases the per-item lock so the un-`.processed` item is
+    // re-delivered on the next poll; a crash mid-flight leaves the admission for
+    // recoverInFlight() to re-deliver on restart.
+    recordInFlight(item, service);
+    _dispatch(prompt, item, classResult, "inbox", {
+      onClose: ({ ok, code, sessionId, stdout }) => {
+        if (ok) {
+          markProcessed(item, service);
+          clearInFlight(item);
+          // Post-session write-back: land a one-line distillation of the work
+          // into the org's shared store so the fleet's memory compounds.
+          // Best-effort + fail-open — fire-and-forget, never blocks finalize.
+          Promise.resolve(writeBackSession(item, classResult, { sessionId }))
+            .catch(() => { /* fail-open */ });
+          // Post-session OUTCOME DISCIPLINE (parity with hq's meeting chair): a
+          // turn that committed to next steps must not leave them in a session
+          // log. Capture them off the turn's final text and land them through the
+          // org protocol (board.create + knowledge.append). OFF unless
+          // DAEMON_SESSION_OUTCOMES=1; idempotent + fail-open; fire-and-forget.
+          Promise.resolve(sweepOutcomesForSession({ sessionId, stdout, item, classResult }))
+            .catch(() => { /* fail-open */ });
+          // Finalize (interaction end): emit `sent` carrying the SAME trace_id
+          // minted at item_received, so the full hop chain (item_received → … →
+          // sent) groups by one stable id. The session itself posts the actual
+          // user-facing reply via the Slack/Gmail APIs; this row marks the clean
+          // close of the work the user's message kicked off.
+          emitEvent({ type: EVENT_TYPES.SENT, trace_id, attrs: { item_id: itemId, service, exit_code: code } });
+        } else {
+          // Leave the inbox file un-`.processed` (re-deliverable). Drop the
+          // admission + release the per-item lock so the next poll re-delivers
+          // immediately rather than waiting out the stale-lock TTL.
+          clearInFlight(item);
+          const key = inflightKey(item);
+          if (key) releaseLock(key);
+          emitEvent({ type: EVENT_TYPES.ERROR, trace_id, attrs: { item_id: itemId, service, exit_code: code, stage: "session_close" } });
+        }
+      },
+    });
+    recordSession(false); // spawned
+
+  } catch (err) {
+    console.error(`[daemon] Failed to process item ${itemId}:`, err.message);
+    recordClassification(false);
+    emitEvent({ type: EVENT_TYPES.ERROR, trace_id, attrs: { item_id: itemId, service, stage: "process_item", error: err.message } });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Hook-bus wiring — register the ONE real lifecycle subscriber.
+// ---------------------------------------------------------------------------
+//
+// The bus (lib/hooks/bus.mjs) exists so cross-cutting controls become SUBSCRIBERS
+// to well-known lifecycle events instead of bespoke wiring. We register a real
+// onGuardFail subscriber here so the bus is live with at least one consumer: each
+// emit("onGuardFail", ctx) — fired wherever a guard fails open — bumps the
+// durable `guard.fail` counter doctor reads. Idempotent: a module-level flag
+// prevents double-subscription if init runs twice (re-import in tests, etc.).
+
+let _hookSubscribersRegistered = false;
+
+/**
+ * Wire the daemon's lifecycle-bus subscribers. Exported + idempotent so a test
+ * can drive it directly and assert the subscriber fires, without spinning the
+ * poll loops. Best-effort: a subscribe failure is swallowed (the bus is
+ * fail-open; a missing subscriber degrades to "uncounted", never a crash).
+ *
+ * @returns {boolean} true if the subscriber is now registered
+ */
+export function registerHookSubscribers() {
+  if (_hookSubscribersRegistered) return true;
+  try {
+    getHookBus().subscribe("onGuardFail", (ctx) => counters.bump("guard.fail", ctx));
+    _hookSubscribersRegistered = true;
+    return true;
+  } catch (err) {
+    console.warn(`[daemon] Failed to register hook subscribers: ${err.message}`);
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Post-session org-memory write-back — land a short distillation of the work
+// this turn did into the org's shared, ACL'd store (central store via the
+// existing memory.author / knowledge.append RPC). Fail-open + best-effort:
+// disabled/unreachable ⇒ a benign no-op; never throws into the dispatch path.
+// Local interaction logs / SQLite remain the fail-open cache.
+// ---------------------------------------------------------------------------
+
+// Cached org config (config/org.yaml) — read once per process. undefined until loaded.
+let _cachedDaemonOrgCfg;
+
+function daemonOrgCfg() {
+  if (_cachedDaemonOrgCfg !== undefined) return _cachedDaemonOrgCfg;
+  try {
+    _cachedDaemonOrgCfg = loadOrgConfig(AGENT_REPO_DIR) || {};
+  } catch {
+    _cachedDaemonOrgCfg = {};
+  }
+  return _cachedDaemonOrgCfg;
+}
+
+/** For tests: reset the cached org config so a fresh config/org.yaml is re-read. */
+export function _resetDaemonOrgCfgCache() {
+  _cachedDaemonOrgCfg = undefined;
+}
+
+// A distillation longer than this is truncated before it lands in the store —
+// the shared memory holds a salient one-liner, never a transcript.
+const SESSION_DISTILL_MAX_CHARS = 400;
+
+/**
+ * Distil a completed turn into one salient line for the shared store. Pure +
+ * bounded; draws only on the item + classification the onClose closure holds
+ * (the session's own actions are audited separately). Returns null when there is
+ * nothing worth remembering.
+ *
+ * @param {object} item inbox item that was processed (may be null for backlog)
+ * @param {object} classResult classifier output
+ * @param {object} [opts] - { agent?, queueItem? } — injectable for tests
+ * @returns {string|null}
+ */
+export function sessionDistillation(item, classResult, opts = {}) {
+  const agent = opts.agent || loadAgent();
+  const who = (agent && agent.firstName) ? agent.firstName : "The agent";
+  const action = (classResult && classResult.action) || "handled";
+  const sender = (item && item.sender) ? String(item.sender) : null;
+  const queueItem = opts.queueItem;
+  const topic =
+    (classResult && classResult.summary) ||
+    (item && item.subject) ||
+    (queueItem && queueItem.title) ||
+    (item && item.content ? String(item.content).slice(0, 160) : null);
+  if (!topic && !sender) return null;
+
+  const parts = [`${who} ${action}`];
+  if (sender) parts.push(`a request from ${sender}`);
+  if (topic) parts.push(`re: ${String(topic).trim()}`);
+  let text = `${parts.join(" ")} (${today()}).`;
+  if (text.length > SESSION_DISTILL_MAX_CHARS) {
+    text = text.slice(0, SESSION_DISTILL_MAX_CHARS - 1) + "…";
+  }
+  return text;
+}
+
+/**
+ * Write a completed turn's distillation to the org's shared store. Fail-open:
+ * disabled/unreachable/empty ⇒ `{ok:false, skipped:true}`; never throws. The
+ * server assigns the fact's group/ACL from the caller's verified identity — we
+ * pass no group hint, so it lands in the caller's default org scope.
+ *
+ * @param {object} item
+ * @param {object} classResult
+ * @param {object} [opts] - { cfg?, rememberImpl?, agent?, queueItem?, sessionId? } — injectable for tests
+ * @returns {Promise<{ok:boolean, skipped?:boolean}>}
+ */
+export async function writeBackSession(item, classResult, opts = {}) {
+  try {
+    const cfg = opts.cfg !== undefined ? opts.cfg : daemonOrgCfg();
+    if (!orgEnabled(cfg)) return { ok: false, skipped: true };
+    const text = sessionDistillation(item, classResult, opts);
+    if (!text) return { ok: false, skipped: true };
+    const rememberImpl = opts.rememberImpl || orgRemember;
+    return await rememberImpl(text, {
+      cfg,
+      kind: "episode",
+      provenance: { source: "daemon-session", sessionId: opts.sessionId || null },
+    });
+  } catch {
+    // Fail-open: the shared-memory write must never take down the dispatch path.
+    return { ok: false, skipped: true };
+  }
+}
+
+/**
+ * Post-session OUTCOME DISCIPLINE — the daemon's parity with hq's meeting chair.
+ *
+ * hq guarantees that a live call's action points become real board rows, with a
+ * teardown sweep for the ones the chair captured but never wrote. A daemon turn
+ * had no such guarantee: it could commit to next steps that then existed only in
+ * `state/sessions/logs/<id>.log`.
+ *
+ * This is the DRIVEN half — the dispatcher's close path calls it, so the
+ * guarantee does not depend on the model remembering to write anything down. The
+ * work itself (capture → board.create + knowledge.append) lives in
+ * ./session-outcomes.mjs; this wrapper only supplies the daemon's own collaborators
+ * (org config + agent identity).
+ *
+ * OFF unless `DAEMON_SESSION_OUTCOMES=1`. Idempotent + fail-open; never throws.
+ *
+ * @param {object} a - { sessionId, stdout?, item?, classResult? } plus test seams
+ *   ({ cfg?, enabled?, agent?, createItemImpl?, rememberImpl? })
+ * @returns {Promise<{created:number, captured?:number, skipped?:boolean, reason?:string}>}
+ */
+export async function sweepOutcomesForSession(a = {}) {
+  try {
+    const cfg = a.cfg !== undefined ? a.cfg : daemonOrgCfg();
+    let agentName = a.agentName;
+    if (!agentName) {
+      const agent = a.agent || loadAgent();
+      agentName = (agent && agent.firstName) || "The agent";
+    }
+    return await sweepSessionOutcomes({ ...a, cfg, agentName });
+  } catch {
+    // Fail-open: outcome landing must never take down the dispatch path.
+    return { created: 0, skipped: true, reason: "error" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Mark inbox item as processed
+// ---------------------------------------------------------------------------
+
+export function markProcessed(item, service) {
+  // The pollers write files to state/inbox/{service}/
+  // We mark them by renaming to .processed
+  try {
+    const inboxDir = join(AGENT_REPO_DIR, "state", "inbox", service);
+    const files = readdirSync(inboxDir).filter(
+      (f) => !f.endsWith(".processed") && (f.includes(item.id) || f.includes(item.raw_ref))
+    );
+    for (const file of files) {
+      const src = join(inboxDir, file);
+      const dst = join(inboxDir, file + ".processed");
+      renameSync(src, dst);
+    }
+  } catch {
+    // Not all items have inbox files (e.g. backlog items)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// In-flight admission — durable record of an inbox item handed to a spawned
+// session, so the F1/H2 message-loss window is closed.
+// ---------------------------------------------------------------------------
+//
+// Previously processItem() called markProcessed() (rename → .processed)
+// IMMEDIATELY after the fire-and-forget dispatch(). A crash before the spawned
+// session closed left the item `.processed` with redelivery blocked → the user's
+// message was lost.
+//
+// Now: after dispatching a session we write a durable in-flight admission file
+// and DEFER markProcessed() to the dispatch onClose success path. On a clean
+// close we finalize (markProcessed + clear the admission). On a non-zero close
+// or spawn error we clear the admission and release the per-item lock, leaving
+// the un-`.processed` inbox file re-deliverable on the next poll. On a crash
+// mid-flight the admission file survives; recoverInFlight() (startup) releases
+// the held per-item lock so the still-un-`.processed` item is re-polled.
+//
+// Idempotency: a re-delivered item that actually completed before the crash is
+// caught by the existing dedup layers (per-item lock on re-poll, thread/channel
+// lock, request-claim, and the sent-message registry) — so redelivery never
+// double-acts.
+
+function inflightDir() {
+  const dir = join(AGENT_REPO_DIR, "state", "inbox-inflight");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Stable per-item key: same precedence as the daemon's acquireLock + the
+ * dispatcher's lock release (raw_ref first, then id), so recovery can release
+ * the exact lock that is gating redelivery. */
+function inflightKey(item) {
+  return item.raw_ref || item.id || null;
+}
+
+/**
+ * Record a durable in-flight admission for an inbox item whose session was just
+ * dispatched. Best-effort: a write failure only means this item won't be
+ * auto-recovered after a crash (it still finalizes normally on close) — never
+ * throws into the dispatch path.
+ */
+export function recordInFlight(item, service) {
+  const key = inflightKey(item);
+  if (!key) return;
+  try {
+    const path = join(inflightDir(), `${sanitiseItemId(key)}.json`);
+    const tmp = path + ".tmp";
+    writeFileSync(tmp, JSON.stringify({
+      lockKey: key,
+      itemId: item.id || null,
+      raw_ref: item.raw_ref || null,
+      service,
+      sender: item.sender || null,
+      channel: item.channel || item.channel_id || null,
+      // Carry the interaction's trace_id onto the durable admission so a
+      // post-crash recovery (or an audit join) can correlate the re-delivered
+      // item back to its original interaction. Cheap + additive.
+      trace_id: item.trace_id || null,
+      admittedAt: new Date().toISOString(),
+    }, null, 2));
+    renameSync(tmp, path);
+  } catch (err) {
+    console.warn(`[daemon] Failed to record in-flight admission for ${key}: ${err.message}`);
+  }
+}
+
+/** Clear the in-flight admission once a dispatched session reaches a terminal
+ * state (success → finalized; failure → left re-deliverable). Best-effort. */
+export function clearInFlight(item) {
+  const key = inflightKey(item);
+  if (!key) return;
+  try { unlinkSync(join(inflightDir(), `${sanitiseItemId(key)}.json`)); }
+  catch { /* already gone */ }
+}
+
+/**
+ * On startup, recover inbox items that were mid-flight when the daemon
+ * crashed/rebooted. For each surviving admission file we release the per-item
+ * lock that would otherwise gate redelivery for the full stale-lock TTL, then
+ * delete the admission file. The inbox file itself was never marked `.processed`
+ * (markProcessed is deferred to clean close), so the next poll re-delivers it
+ * through the normal pipeline — where the dedup layers prevent any double-act if
+ * the work had in fact completed before the crash.
+ *
+ * @returns {number} count of in-flight admissions recovered
+ */
+export function recoverInFlight() {
+  let recovered = 0;
+  let files = [];
+  try {
+    files = readdirSync(inflightDir()).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp"));
+  } catch { return 0; }
+  for (const file of files) {
+    const path = join(inflightDir(), file);
+    let rec = null;
+    try { rec = JSON.parse(readFileSync(path, "utf-8")); } catch { /* corrupt */ }
+    try {
+      if (rec && rec.lockKey) releaseLock(rec.lockKey);
+      unlinkSync(path);
+      recovered++;
+    } catch { /* best-effort */ }
+  }
+  if (recovered > 0) {
+    console.log(`[daemon] Recovered ${recovered} in-flight inbox item(s) for redelivery`);
+  }
+  return recovered;
+}
+
+// ---------------------------------------------------------------------------
+// Backlog Sweep
+// ---------------------------------------------------------------------------
+
+async function sweepBacklog() {
+  const slots = availableSlots();
+  if (slots <= 0) return; // No capacity
+
+  try {
+    const queueDir = join(AGENT_REPO_DIR, "state", "queues");
+    const files = readdirSync(queueDir).filter((f) => f.endsWith(".yaml"));
+    const actionableItems = [];
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(queueDir, file), "utf-8");
+        // Parse via the shared, tested parser (lib/backlog.mjs). The previous
+        // inline parser never extracted the item `id` (and split only on
+        // column-0 dashes, folding js-yaml's indented `  - id:` items into one
+        // block) — so qi.id was always undefined and the entire file-based
+        // item-claim subsystem (hasActiveClaim/claimItem) was dead. (0.8 / F2)
+        actionableItems.push(...parseQueueItems(content, file));
+      } catch {
+        // Skip unparseable queue files
+      }
+    }
+
+    // Sort: critical first, then high, then normal
+    const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
+    actionableItems.sort((a, b) => (priorityOrder[a.priority] || 3) - (priorityOrder[b.priority] || 3));
+
+    // Filter out items that already have active sessions or exceeded retries
+    const dispatchable = actionableItems.filter((qi) => {
+      const check = canDispatchBacklog(qi);
+      if (!check.allowed) {
+        if (check.reason === "max_retries_exceeded") {
+          console.log(`[daemon] Backlog skip: "${qi.title}" — retries exhausted`);
+        }
+        return false;
+      }
+
+      // File-based item claim check — survives daemon restart and is visible
+      // to concurrent launchd triggers. Complements in-memory activeBacklogKeys.
+      // (ib-20260407-001b: concurrent session coordination)
+      if (qi.id && hasActiveClaim(qi.id)) {
+        console.log(`[daemon] Backlog skip: "${qi.title}" — item claimed by another session`);
+        return false;
+      }
+
+      return true;
+    });
+
+    // Dispatch top items up to available slots
+    const toDispatch = dispatchable.slice(0, Math.min(slots, 5));
+    let dispatched = 0;
+
+    for (const queueItem of toDispatch) {
+      const classResult = {
+        priority: queueItem.priority,
+        action: "queue",
+        model: queueItem.priority === "critical" ? "opus" : "sonnet",
+        summary: queueItem.title,
+        category: "action_required",
+      };
+
+      const prompt = await buildPrompt(null, classResult, {
+        type: "backlog",
+        queueItem,
+      });
+
+      // Backlog turns commit to next steps just as readily as inbox turns, so
+      // they get the same outcome discipline. This onClose does NOT touch the
+      // backlog finalize path (the session updates its own queue item) — it is
+      // purely the outcome sweep, gated off by default.
+      dispatch(prompt, queueItem, classResult, "backlog", {
+        onClose: ({ ok, sessionId, stdout }) => {
+          if (!ok) return;
+          Promise.resolve(sweepOutcomesForSession({ sessionId, stdout, item: queueItem, classResult }))
+            .catch(() => { /* fail-open */ });
+        },
+      });
+      recordSession(false);
+      dispatched++;
+    }
+
+    if (dispatched > 0) {
+      console.log(`[daemon] Backlog sweep: dispatched ${dispatched} items (${actionableItems.length - dispatchable.length} skipped: in-flight or exhausted)`);
+    }
+  } catch (err) {
+    console.error(`[daemon] Backlog sweep error:`, err.message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  console.log("╔══════════════════════════════════════════════════════════╗");
+  console.log(`║          ${(loadAgent().firstName || "Agent").padEnd(8)} Daemon — Reactive Event Processor       ║`);
+  console.log("╠══════════════════════════════════════════════════════════╣");
+  console.log(`║  Directory:   ${AGENT_REPO_DIR}`);
+  console.log(`║  Poll:        every ${POLL_INTERVAL / 1000}s`);
+  console.log(`║  Backlog:     every ${BACKLOG_INTERVAL / 1000}s`);
+  console.log(`║  Concurrency: up to ${process.env.DAEMON_MAX_CONCURRENT || 10} parallel sessions`);
+  console.log("╚══════════════════════════════════════════════════════════╝");
+
+  // Observability: register the ONE real hook-bus subscriber so the lifecycle
+  // bus is LIVE (not a dead seam). Every onGuardFail emit (where a guard fails
+  // open elsewhere in the pipeline) increments the durable `guard.fail` counter
+  // that doctor/operators read. subscribe + bump are both fail-open; an init
+  // failure here can never stop the daemon coming up.
+  registerHookSubscribers();
+
+  // Check for emergency stop
+  try {
+    readFileSync(join(AGENT_REPO_DIR, ".emergency-stop"));
+    console.error("[daemon] Emergency stop active — exiting");
+    process.exit(0);
+  } catch {
+    // No emergency stop — continue
+  }
+
+  // Clear orphaned state from prior daemon instances
+  const staleCleared = scanStaleLocks();
+  if (staleCleared > 0) {
+    console.log(`[daemon] Cleared ${staleCleared} stale session locks`);
+  }
+  // F1/H2: re-deliver inbox items that were mid-flight when this box crashed.
+  // Each surviving in-flight admission's per-item lock is released so the
+  // still-un-`.processed` file is re-polled (dedup layers prevent double-acting
+  // if the work had completed). Runs BEFORE the first poll so recovery wins the
+  // race against re-acquisition.
+  recoverInFlight();
+  // WS4: on startup, reconcile in-flight session resume markers — re-dispatch
+  // `claude --print --resume` for any work that was mid-flight when the box
+  // rebooted/lost power (3-strike cap → status:blocked). Shutdown paths below
+  // call resetActiveSessions() WITHOUT reconcile so we never re-spawn work we
+  // are deliberately stopping.
+  resetActiveSessions({ reconcile: true });
+
+  // Initial poll immediately
+  await poll();
+
+  // Poll loop
+  setInterval(async () => {
+    try {
+      // Check emergency stop
+      try { readFileSync(join(AGENT_REPO_DIR, ".emergency-stop")); process.exit(0); } catch {}
+      await poll();
+    } catch (err) {
+      console.error("[daemon] Poll loop error:", err.message);
+    }
+  }, POLL_INTERVAL);
+
+  // Backlog sweep
+  setInterval(async () => {
+    try {
+      await sweepBacklog();
+    } catch (err) {
+      console.error("[daemon] Backlog sweep error:", err.message);
+    }
+  }, BACKLOG_INTERVAL);
+
+  // Health dashboard + stale claim sweep
+  setInterval(() => {
+    try {
+      writeHealthDashboard();
+      // Sweep stale item claims (ib-20260407-001b: concurrent session coordination)
+      const claimsSwept = sweepStaleItemClaims();
+      if (claimsSwept > 0) {
+        console.log(`[daemon] Swept ${claimsSwept} stale item claims`);
+      }
+    } catch (err) {
+      console.error("[daemon] Health write error:", err.message);
+    }
+  }, HEALTH_INTERVAL);
+
+  // Graceful shutdown — clean up active.json so next startup doesn't see stale sessions
+  process.on("SIGTERM", () => {
+    console.log("[daemon] SIGTERM received, shutting down gracefully");
+    resetActiveSessions();
+    writeHealthDashboard();
+    process.exit(0);
+  });
+
+  process.on("SIGINT", () => {
+    console.log("[daemon] SIGINT received, shutting down");
+    resetActiveSessions();
+    writeHealthDashboard();
+    process.exit(0);
+  });
+
+  console.log("[daemon] Running. Ctrl+C to stop.");
+}
+
+// Autostart on import (production: launched directly via `node agent-daemon.mjs`
+// or imported by maestro-daemon.mjs — both expect main() to run). A test may set
+// MAESTRO_DAEMON_NO_AUTOSTART before importing to exercise the exported helpers
+// (recoverInFlight, etc.) in isolation without spinning up the poll loops.
+if (!process.env.MAESTRO_DAEMON_NO_AUTOSTART) {
+  main().catch((err) => {
+    console.error("[daemon] Fatal:", err);
+    process.exit(1);
+  });
+}