@cohortapp/agent-sdk 2.3.1 → 2.4.0

package/scripts/daemon/cadence-handlers.mjs

@@ -48,6 +48,7 @@ import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { recoverStaleClaims } from "../../lib/cadence-bus.mjs";
 import { isQuarterStartMonth } from "../../lib/cadences.mjs";
+import { loadOrgConfig } from "../../lib/org/client.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -389,13 +390,40 @@ async function guardQuarterlySelfAssessment({ now } = {}) {
 
 /** Read config/agent.json fail-open (for the org legs). Returns null on any error. */
 function loadAgentCfg(agentRoot) {
+  let agent = null;
   try {
     const p = join(agentRoot, "config", "agent.json");
-    if (!existsSync(p)) return null;
-    return JSON.parse(readFileSync(p, "utf8"));
+    if (existsSync(p)) agent = JSON.parse(readFileSync(p, "utf8"));
   } catch {
-    return null;
+    agent = null;
+  }
+
+  // ORG ENROLMENT LIVES IN config/org.yaml, NOT config/agent.json.
+  //
+  // Every org-facing guard below gates on `cfg.org.cohort` and bails out with
+  // "org messaging not configured" when it is absent. `config/agent.json` has no
+  // `org` key at all — enrolment is written to `config/org.yaml` by
+  // `maestro setup` and read by lib/org/client.loadOrgConfig — so all SIX of
+  // those guards were dead on every enrolled agent, silently and permanently.
+  //
+  // Observed in production: a human DM'd an agent repeatedly and the
+  // messaging-inbound cadence ran ~every 45s, each time deciding "org messaging
+  // not configured" and routing nothing. The agent looked healthy the whole time.
+  //
+  // This is the SAME bug class loadOrgConfig was introduced to fix ("the daemon
+  // reading collective.yaml by mistake") — fixed there, missed here. Merging at
+  // this one chokepoint fixes every guard at once rather than per-guard.
+  let org = null;
+  try {
+    org = loadOrgConfig(agentRoot);
+  } catch {
+    org = null;
+  }
+
+  if (org && org.org) {
+    return { ...(agent || {}), org: { ...((agent && agent.org) || {}), ...org.org } };
   }
+  return agent;
 }
 
 /**
@@ -633,7 +661,17 @@ async function guardMessagingInbound({ event, agentRoot, log }, opts = {}) {
     const writeInboxItem = opts.writeImpl || (await import("../poller/utils.mjs")).writeInboxItem;
 
     const cursor = readMessagingCursor(agentRoot);
-    const res = await pull({ cfg, cursor, fetchImpl: opts.fetchImpl });
+    // Pass the agent id explicitly. It is what suppresses the agent's OWN
+    // outbound echoes — without it `me` is null, every echo-filter branch is
+    // skipped, and the agent re-ingests its own replies as fresh inbound (a
+    // conversation with itself). config/org.yaml does not carry an agentId, so
+    // env is the reliable source on a real machine.
+    const agentId =
+      opts.agentId ||
+      process.env.COHORT_AGENT_ID ||
+      (cfg && cfg.org && cfg.org.cohort && cfg.org.cohort.agentId) ||
+      undefined;
+    const res = await pull({ cfg, agentId, cursor, fetchImpl: opts.fetchImpl });
     const events = (res && Array.isArray(res.events)) ? res.events : [];
 
     let routed = 0;
@@ -879,6 +917,122 @@ async function guardBrandSteward({ event, agentRoot, log }, opts = {}) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// goal-steward (D3, SPEC §6.3) — the self-directed reconciliation loop
+// ---------------------------------------------------------------------------
+
+/**
+ * Refresh the cached mandate, then run one goal-steward pass INLINE.
+ *
+ * Guarded rather than escalate on purpose. The whole measure → gap → decide →
+ * admit → classify → route pass is deterministic local computation plus sensor
+ * reads; there is nothing for a model to do unless a gap needs *candidates*
+ * that the deterministic planner cannot produce. So:
+ *
+ *   - no adopted mandate                     → inline, zero cost, one log line
+ *   - every objective within tolerance       → inline
+ *   - a gap that produced admitted work      → inline (the work is already
+ *                                              queued + routed)
+ *   - a gap the loop wants richer candidates
+ *     for (observe-only, or a repeatedly
+ *     failed intervention)                   → escalate to a planning session
+ *
+ * Never throws: every failure path returns `{ok:false, …}` with a reason so the
+ * consumer can archive/DLQ, and every degradation is logged.
+ *
+ * @param {object} ctx - { event, agentRoot, log }
+ * @param {object} [opts] - injectable seams: { runImpl, refreshImpl, cfg, enforcement, now, fetchImpl }
+ */
+async function guardGoalSteward({ event, agentRoot, log }, opts = {}) {
+  const cadence = event && event.cadence ? event.cadence : "goal-steward";
+  const say = typeof log === "function" ? log : () => {};
+  try {
+    // 1. Refresh the mandate cache first — a goal loop running off a week-old
+    //    mandate is worse than one that does not run. Fail-open: the loop's own
+    //    staleness ladder is what actually decides what it may do.
+    if (opts.refreshImpl !== null) {
+      try {
+        const refresh = opts.refreshImpl || (await import("../../lib/mandate/refresh.mjs")).refreshMandate;
+        const r = await refresh(agentRoot, { fetchImpl: opts.fetchImpl, log: say, now: opts.now });
+        if (r && r.ok === false) {
+          say("warn", `[goal-steward] mandate refresh failed (${r.reason}) — running on the cached mandate`);
+        }
+      } catch (err) {
+        say("warn", `[goal-steward] mandate refresh threw (${err && err.message ? err.message : err}) — running on the cached mandate`);
+      }
+    }
+
+    // 2. Enforcement posture. OBSERVE unless config/plan.yaml says otherwise —
+    //    the loop must not create work on day one.
+    let enforcement = opts.enforcement;
+    if (enforcement === undefined) {
+      enforcement = "observe";
+      try {
+        const p = join(agentRoot, "config", "plan.yaml");
+        if (existsSync(p)) {
+          const m = readFileSync(p, "utf-8").match(/^\s*enforcement:\s*["']?(\w+)["']?/m);
+          if (m && m[1] === "active") enforcement = "active";
+        }
+      } catch (err) {
+        say("warn", `[goal-steward] could not read config/plan.yaml enforcement (${err && err.message ? err.message : err}) — staying observe-only`);
+      }
+    }
+
+    const run = opts.runImpl || (await import("../../lib/goals/loop.mjs")).runGoalSteward;
+    const report = await run({ agentRoot, log: say, enforcement, now: opts.now, ...(opts.runDeps || {}) });
+
+    if (!report || report.ok === false) {
+      // Not an error for the bus: "no mandate" is the normal pre-adoption state.
+      return {
+        ok: true,
+        decision: "inline",
+        cadence,
+        reason: (report && report.skipped) || "goal loop could not run",
+        measured: 0,
+        admitted: 0,
+      };
+    }
+
+    const measured = (report.measured || []).length;
+    const admitted = (report.admitted || []).length;
+    const rejected = (report.rejected || []).length;
+    const escalations = (report.escalations || []).length;
+    const drift = (report.drift || []).length;
+
+    if (report.skipped) {
+      return { ok: true, decision: "inline", cadence, reason: report.skipped, measured, admitted, drift };
+    }
+
+    say(
+      "info",
+      `[goal-steward] ${enforcement}: measured ${measured}, admitted ${admitted}, rejected ${rejected}, escalations ${escalations}, drift ${drift}`
+    );
+
+    // 3. Escalate only when a model would actually add something: an open gap
+    //    that produced no admitted work and no escalation of its own.
+    const unserved = (report.decisions || []).filter(
+      (d) => d.action === "create" && !(report.admitted || []).some((a) => a.objectiveKey === d.objectiveKey)
+    );
+    if (unserved.length > 0 && enforcement === "active") {
+      return {
+        ok: true,
+        decision: "escalate",
+        cadence,
+        reason: `${unserved.length} objective(s) have an open gap the deterministic planner could not serve`,
+        objectives: unserved.map((d) => d.objectiveKey),
+        measured,
+        admitted,
+      };
+    }
+
+    return { ok: true, decision: "inline", cadence, measured, admitted, rejected, escalations, drift, enforcement };
+  } catch (err) {
+    // Fail-open but LOUD: the daemon keeps running, the failure is on the record.
+    say("error", `[goal-steward] guard threw: ${err && err.message ? err.message : err}`);
+    return { ok: false, decision: "inline", cadence, error: String(err && err.message ? err.message : err) };
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Registry
 // ---------------------------------------------------------------------------
@@ -1060,6 +1214,23 @@ export const CADENCE_REGISTRY = {
       "design_propose_change", "messaging_send",
     ],
   },
+
+  "goal-steward": {
+    mode: "guarded",
+    guard: guardGoalSteward,
+    prompt: "schedules/triggers/goal-steward.md",
+    description:
+      "The self-directed loop (SPEC §6.3): measure every adopted objective whose window is open, compute the gap against target/tolerance/trend, and turn a real gap into real, provenance-linked backlog — classified SELF/COLLABORATE/HANDOFF/NEEDS_REVIEW and routed through the existing handoff/lease/approval primitives. Guarded: the whole pass runs inline; it escalates only when an open gap needs candidates the deterministic planner cannot produce. Observe-only until config/plan.yaml sets enforcement: active.",
+    // Reads + the collaboration primitives. No shell, no send-to-external:
+    // the loop proposes and routes; anything gated goes through approval.
+    allowedTools: [
+      "Read", "Grep", "Glob", "LS",
+      "mandate_get", "mandate_propose", "mandate_sample",
+      "board_create", "board_comment", "board_context",
+      "handoff_offer", "approval_request", "escalation_ask",
+      "task_create", "messaging_send",
+    ],
+  },
 };
 
 // Optional config-driven cadence registry (config/.cadence-registry.json),
@@ -1088,7 +1259,17 @@ export function getCadenceDef(name) {
   if (CADENCE_REGISTRY[name]) return CADENCE_REGISTRY[name];
   const cfg = loadConfigRegistry()[name];
   if (cfg && cfg.prompt) {
-    return { mode: cfg.mode || "escalate", prompt: cfg.prompt, description: "archetype cadence (config-driven)" };
+    // EXTENDED registry shape (plan compiler, lib/plan/emit.mjs): a plan-derived
+    // cadence carries its own tool scope, guard and budget. Passing these through
+    // is what lets lib/session-permissions.resolveAllowlist() scope the spawn
+    // instead of falling back to the conservative default — without it, every
+    // derived cadence would run wider than its obligation declares.
+    const def = { mode: cfg.mode || "escalate", prompt: cfg.prompt, description: "archetype/plan cadence (config-driven)" };
+    if (Array.isArray(cfg.allowedTools) && cfg.allowedTools.length) def.allowedTools = cfg.allowedTools;
+    if (cfg.guardModule) def.guardModule = cfg.guardModule;
+    if (Number.isFinite(cfg.budgetCents)) def.budgetCents = cfg.budgetCents;
+    if (cfg.obligationKey) def.obligationKey = cfg.obligationKey;
+    return def;
   }
   return null;
 }
@@ -1118,4 +1299,5 @@ export {
   guardMessagingInbound,
   guardDirectoryHygiene,
   guardBrandSteward,
+  guardGoalSteward,
 };

package/scripts/daemon/goal-steward-cadence.test.mjs

@@ -0,0 +1,243 @@
+/**
+ * scripts/daemon/goal-steward-cadence.test.mjs — the wiring that makes the
+ * self-directed loop actually RUN.
+ *
+ * Before this, `lib/goals/loop.mjs` existed and nothing ever called it: no
+ * standard cadence, no registry entry, no plist. A loop nobody triggers is a
+ * design document. These tests pin the trigger down:
+ *
+ *   - `goal-steward` is a STANDARD cadence, so every agent gets a plist for it
+ *   - it is GUARDED, so an agent with no adopted mandate costs ~nothing
+ *   - it refreshes the mandate BEFORE measuring
+ *   - it defaults to observe-only, whatever the caller forgot to pass
+ *   - it escalates only when an open gap needs candidates it cannot produce
+ */
+
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { CADENCE_REGISTRY, getCadenceDef, guardGoalSteward } from "./cadence-handlers.mjs";
+import { STANDARD_CADENCES } from "../../lib/cadences.mjs";
+
+function makeRoot() {
+  const root = mkdtempSync(join(tmpdir(), "goal-cadence-"));
+  mkdirSync(join(root, "config"), { recursive: true });
+  return root;
+}
+function cleanup(root) { try { rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ } }
+
+/** Baseline seams: no network, no real loop. */
+function seams(over = {}) {
+  return {
+    refreshImpl: async () => ({ ok: true, source: "server", tier: "fresh" }),
+    runImpl: async () => ({ ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }),
+    ...over,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+test("goal-steward is a STANDARD cadence, so every agent gets one", () => {
+  const c = STANDARD_CADENCES.find((x) => x.id === "goal-steward");
+  assert.ok(c, "the loop must have a trigger or it never runs");
+  assert.equal(c.scope, "standard");
+  assert.equal(c.mode, "guarded");
+  // Daily, on a calendar slot — not a hot interval.
+  assert.deepEqual(c.calendar, { hour: 7, minute: 15 });
+  assert.equal(c.prompt, "schedules/triggers/goal-steward.md");
+});
+
+test("the daemon can route the cadence it is about to be sent", () => {
+  const def = getCadenceDef("goal-steward");
+  assert.ok(def, "an unroutable cadence DLQs every tick");
+  assert.equal(def.mode, "guarded");
+  assert.equal(typeof def.guard, "function");
+  assert.equal(CADENCE_REGISTRY["goal-steward"].guard, guardGoalSteward);
+  // Scoped tool surface: reads + collaboration primitives, no shell.
+  const tools = CADENCE_REGISTRY["goal-steward"].allowedTools;
+  assert.ok(Array.isArray(tools) && tools.length > 0);
+  assert.ok(tools.includes("approval_request"), "gated work must be able to reach the approval path");
+  assert.ok(!tools.includes("Bash"), "the goal loop has no business running shell");
+});
+
+// ---------------------------------------------------------------------------
+// The guard
+// ---------------------------------------------------------------------------
+
+test("the mandate is refreshed BEFORE the loop measures anything", async () => {
+  const root = makeRoot();
+  try {
+    const order = [];
+    await guardGoalSteward({ event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} }, seams({
+      refreshImpl: async () => { order.push("refresh"); return { ok: true }; },
+      runImpl: async () => { order.push("run"); return { ok: true, measured: [], admitted: [], decisions: [] }; },
+    }));
+    assert.deepEqual(order, ["refresh", "run"], "measuring against a stale mandate is worse than not measuring");
+  } finally { cleanup(root); }
+});
+
+test("enforcement defaults to OBSERVE when config/plan.yaml says nothing", async () => {
+  const root = makeRoot();
+  try {
+    let seen = null;
+    await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async (d) => { seen = d.enforcement; return { ok: true, measured: [], admitted: [], decisions: [] }; },
+    }));
+    assert.equal(seen, "observe", "a loop that starts by writing is how you lose a fleet");
+  } finally { cleanup(root); }
+});
+
+test("enforcement:active in config/plan.yaml turns the loop on", async () => {
+  const root = makeRoot();
+  try {
+    writeFileSync(join(root, "config", "plan.yaml"), "version: 1\nenforcement: active\nobligations: []\n", "utf-8");
+    let seen = null;
+    await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async (d) => { seen = d.enforcement; return { ok: true, measured: [], admitted: [], decisions: [] }; },
+    }));
+    assert.equal(seen, "active");
+  } finally { cleanup(root); }
+});
+
+test("any other enforcement value stays observe — fail-closed on the write path", async () => {
+  const root = makeRoot();
+  try {
+    writeFileSync(join(root, "config", "plan.yaml"), "enforcement: yes-please\n", "utf-8");
+    let seen = null;
+    await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async (d) => { seen = d.enforcement; return { ok: true, measured: [], admitted: [], decisions: [] }; },
+    }));
+    assert.equal(seen, "observe");
+  } finally { cleanup(root); }
+});
+
+test("no adopted mandate completes INLINE — an idle seat costs one cache read", async () => {
+  const root = makeRoot();
+  try {
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async () => ({ ok: false, skipped: "no mandate cache — this seat has never fetched an adopted mandate" }),
+    }));
+    assert.equal(r.ok, true, "a pre-adoption seat is not a bus failure");
+    assert.equal(r.decision, "inline");
+    assert.match(r.reason, /never fetched an adopted mandate/);
+  } finally { cleanup(root); }
+});
+
+test("a satisfied mandate completes inline and never spawns a session", async () => {
+  const root = makeRoot();
+  try {
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async () => ({
+        ok: true, measured: [{ objectiveKey: "pipeline", value: 4 }], admitted: [], rejected: [],
+        escalations: [], drift: [], decisions: [{ objectiveKey: "pipeline", action: "none" }],
+      }),
+    }));
+    assert.equal(r.decision, "inline");
+    assert.equal(r.measured, 1);
+    assert.equal(r.admitted, 0);
+  } finally { cleanup(root); }
+});
+
+test("a gap the deterministic planner SERVED completes inline — the work is already queued", async () => {
+  const root = makeRoot();
+  try {
+    writeFileSync(join(root, "config", "plan.yaml"), "enforcement: active\n", "utf-8");
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async () => ({
+        ok: true,
+        measured: [{ objectiveKey: "pipeline", value: 1 }],
+        admitted: [{ objectiveKey: "pipeline", title: "Book calls" }],
+        rejected: [], escalations: [], drift: [],
+        decisions: [{ objectiveKey: "pipeline", action: "create" }],
+      }),
+    }));
+    assert.equal(r.decision, "inline", "no model is needed when the work already exists");
+    assert.equal(r.admitted, 1);
+  } finally { cleanup(root); }
+});
+
+test("an UNSERVED open gap escalates to a planning session, naming the objectives", async () => {
+  const root = makeRoot();
+  try {
+    writeFileSync(join(root, "config", "plan.yaml"), "enforcement: active\n", "utf-8");
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async () => ({
+        ok: true,
+        measured: [{ objectiveKey: "pipeline", value: 1 }],
+        admitted: [], rejected: [], escalations: [], drift: [],
+        decisions: [{ objectiveKey: "pipeline", action: "create" }],
+      }),
+    }));
+    assert.equal(r.decision, "escalate");
+    assert.deepEqual(r.objectives, ["pipeline"]);
+  } finally { cleanup(root); }
+});
+
+test("OBSERVE-ONLY never escalates, even with an unserved gap", async () => {
+  const root = makeRoot();
+  try {
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
+      runImpl: async () => ({
+        ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [],
+        decisions: [{ objectiveKey: "pipeline", action: "create" }],
+      }),
+    }));
+    assert.equal(r.decision, "inline", "the observe window must not spend money on planning sessions");
+  } finally { cleanup(root); }
+});
+
+// ---------------------------------------------------------------------------
+// Failure containment
+// ---------------------------------------------------------------------------
+
+test("SERVER UNREACHABLE: a failed mandate refresh degrades to the cache, loudly", async () => {
+  const root = makeRoot();
+  try {
+    const logs = [];
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) }, seams({
+      refreshImpl: async () => ({ ok: false, reason: "call-threw:ECONNREFUSED" }),
+    }));
+    assert.equal(r.ok, true, "a partition must not stop the loop from running on cache");
+    assert.ok(logs.some((l) => /refresh failed/.test(l)));
+  } finally { cleanup(root); }
+});
+
+test("SERVER UNREACHABLE: a THROWING refresh is contained and logged", async () => {
+  const root = makeRoot();
+  try {
+    const logs = [];
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) }, seams({
+      refreshImpl: async () => { throw new Error("ECONNREFUSED"); },
+    }));
+    assert.equal(r.ok, true);
+    assert.ok(logs.some((l) => /refresh threw/.test(l)));
+  } finally { cleanup(root); }
+});
+
+test("a THROWING loop returns ok:false with the error — fail-open but never silent", async () => {
+  const root = makeRoot();
+  try {
+    const logs = [];
+    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) }, seams({
+      runImpl: async () => { throw new Error("loop exploded"); },
+    }));
+    assert.equal(r.ok, false);
+    assert.match(r.error, /loop exploded/);
+    assert.ok(logs.some((l) => l.startsWith("error:")), "the daemon keeps running, the failure is on the record");
+  } finally { cleanup(root); }
+});
+
+test("the guard never throws, whatever it is handed", async () => {
+  const r = await guardGoalSteward({ event: null, agentRoot: "/nonexistent-xyz", log: null }, seams({
+    runImpl: async () => null,
+  }));
+  assert.equal(typeof r.ok, "boolean");
+  assert.equal(r.cadence, "goal-steward");
+});

package/scripts/daemon/inbox-deferral.mjs

@@ -37,7 +37,36 @@
 import { readdirSync, readFileSync, renameSync, existsSync } from "node:fs";
 import { join } from "node:path";
 
-const SERVICE_DIRS = ["slack", "gmail", "calendar", "internal", "sms", "whatsapp"];
+import { signalInbox } from "./inbox-wake.mjs";
+
+/**
+ * Fallback service list, used only when `state/inbox/` cannot be enumerated.
+ *
+ * It used to be the ONLY list, and it was written before the channel-bus and
+ * org services existed: `cohort`, `orgmail` and `telegram` were never in it. A
+ * deferred Cohort DM (the second message of any rapid-fire burst) therefore had
+ * NO promote path at all — `promoteDeferred` looked in six directories, none of
+ * which was `state/inbox/cohort/`, found nothing, and the message stayed
+ * `.deferred` forever. The list is now derived from disk (below) so a new
+ * service can never be silently un-promotable again.
+ */
+const FALLBACK_SERVICE_DIRS = ["slack", "gmail", "calendar", "internal", "sms", "whatsapp"];
+
+/**
+ * Every service inbox that exists on disk. Derived, not enumerated — the
+ * directories ARE the registry (the daemon creates one per configured service).
+ * @param {string} agentRoot
+ * @returns {string[]}
+ */
+function serviceDirs(agentRoot) {
+  try {
+    return readdirSync(join(agentRoot, "state", "inbox"), { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  } catch {
+    return FALLBACK_SERVICE_DIRS;
+  }
+}
 
 /**
  * Rename a live inbox file to its `.deferred` suffix so the scanner
@@ -142,7 +171,7 @@ export function promoteDeferred(channel, agentRoot) {
   const result = { promoted: 0, bundled: 0, service: null };
   if (!channel || !agentRoot) return result;
 
-  for (const service of SERVICE_DIRS) {
+  for (const service of serviceDirs(agentRoot)) {
     const inboxDir = join(agentRoot, "state", "inbox", service);
     if (!existsSync(inboxDir)) continue;
 
@@ -206,5 +235,19 @@ export function promoteDeferred(channel, agentRoot) {
     }
   }
 
+  // The promoted item is live on disk RIGHT NOW, and this runs on the
+  // dispatcher's session-close path — i.e. the moment a burst's next message
+  // becomes answerable. Without a nudge it waits for the daemon's next inbox
+  // sweep, which is the single largest term in the reply latency of a
+  // back-to-back conversation. Free and idempotent: a wake with no work costs
+  // one readdir (scripts/daemon/inbox-wake.mjs).
+  if (result.promoted > 0) {
+    try {
+      signalInbox("promote-deferred");
+    } catch {
+      /* the wake is an optimisation — never let it break the promote */
+    }
+  }
+
   return result;
 }

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

@@ -240,3 +240,59 @@ test("L7: latest-wins uses top-level timestamp, not a body `timestamp:` line", (
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+// --- service-dir discovery (the cohort/orgmail regression) -------------------
+
+/** Write a deferred item into ANY service dir (creating it). */
+function writeDeferredIn(root, service, name, { channel_id, timestamp, id }) {
+  mkdirSync(join(root, "state", "inbox", service), { recursive: true });
+  const body = [
+    `id: "${id}"`,
+    `service: "${service}"`,
+    `channel_id: "${channel_id}"`,
+    `timestamp: "${timestamp}"`,
+    `content: |`,
+    `  body`,
+    "",
+  ].join("\n");
+  writeFileSync(join(root, "state", "inbox", service, name), body);
+}
+
+test("promoteDeferred finds services the hardcoded list never knew about (cohort/orgmail)", () => {
+  const root = makeAgentRoot();
+  try {
+    writeDeferredIn(root, "cohort", "cohort-msg.yaml.deferred", {
+      channel_id: "ch_build",
+      timestamp: "2026-08-11T00:00:00Z",
+      id: "cohort-msg",
+    });
+    const r = promoteDeferred("ch_build", root);
+    assert.equal(r.promoted, 1, "a deferred Cohort message was previously un-promotable forever");
+    assert.equal(r.service, "cohort");
+    assert.deepEqual(readdirSync(join(root, "state", "inbox", "cohort")), ["cohort-msg.yaml"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("promoteDeferred signals the inbox wake so the promoted item is not stuck behind the poll", async () => {
+  const { waitForInboxWake, resetInboxWake } = await import("./inbox-wake.mjs");
+  const root = makeAgentRoot();
+  resetInboxWake();
+  try {
+    writeDeferredIn(root, "cohort", "burst-2.yaml.deferred", {
+      channel_id: "ch_dm",
+      timestamp: "2026-08-11T00:00:01Z",
+      id: "burst-2",
+    });
+    // scanMs is disabled so ONLY the in-process signal can settle this.
+    const waiting = waitForInboxWake({ agentRoot: root, timeoutMs: 3_000, scanMs: 600_000 });
+    setTimeout(() => promoteDeferred("ch_dm", root), 20);
+    const woke = await waiting;
+    assert.equal(woke.woke, true);
+    assert.equal(woke.service, "cohort");
+  } finally {
+    resetInboxWake();
+    rmSync(root, { recursive: true, force: true });
+  }
+});