@cohortapp/agent-sdk 2.4.0 → 2.5.0

package/scripts/daemon/execution-ladder.test.mjs

@@ -0,0 +1,430 @@
+/**
+ * scripts/daemon/execution-ladder.test.mjs — the daemon actually ENTERS
+ * lib/execution/**.
+ *
+ * Run: node --test scripts/daemon/execution-ladder.test.mjs
+ *
+ * `lib/execution/**` had exactly one production importer (lib/goals/loop.mjs,
+ * for `routeRung`); `processItem` went from ITEM_RECEIVED straight to the Haiku
+ * classifier and never entered the ladder. These tests drive the daemon's OWN
+ * entry point — `processItem` — with the network/subprocess collaborators
+ * injected, and assert on what lands in `state/execution/journal.jsonl`,
+ * `state/queues/inbound.yaml` and the fakes. Nothing about intake, match, route,
+ * disposition, drive or journal is faked.
+ *
+ * The two regression tests at the bottom encode bugs a live run of this wiring
+ * actually produced:
+ *   - with no `need` estimate every DM routed to rung 3, which vetoed the quick
+ *     reply and turned a 4-second answer into a spawned Claude session;
+ *   - with the rule-based directedness override applied to ALL ignore reasons,
+ *     a DM could never be `duplicate` (a DM is always "directed"), so the agent
+ *     answered every redelivery twice.
+ */
+import { test, before, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { register } from "node:module";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// --- stub the agent-only `imapflow` dep so the daemon module can be imported ---
+register(
+  "data:text/javascript," +
+    encodeURIComponent(`
+export async function resolve(s, c, next) {
+  if (s === "imapflow") return { url: "imapflow-stub:main", shortCircuit: true };
+  return next(s, c);
+}
+export async function load(u, c, next) {
+  if (u === "imapflow-stub:main") return { format: "module", shortCircuit: true, source: "export class ImapFlow {}" };
+  return next(u, c);
+}
+`),
+);
+
+const AGENT_DIR = mkdtempSync(join(tmpdir(), "maestro-exec-ladder-"));
+process.env.AGENT_DIR = AGENT_DIR;
+process.env.MAESTRO_DAEMON_NO_AUTOSTART = "1";
+process.env.COHORT_AGENT_ID = "mem_self_0001";
+process.env.ANTHROPIC_API_KEY = "";
+
+const PLAN = `version: 1
+enforcement: enforce
+obligations:
+  - key: react.message.dm
+    kind: REACT
+    status: active
+    trigger: { topic: message, kind: null, predicate: null }
+    uses: []
+    allowed_tools: []
+    action_classes: []
+    offline_safe: true
+  - key: react.task.assigned
+    kind: REACT
+    status: active
+    trigger: { topic: task, kind: assigned, predicate: null }
+    uses: []
+    allowed_tools: []
+    action_classes: []
+    offline_safe: true
+`;
+
+let daemon;
+let responder;
+
+before(async () => {
+  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
+  writeFileSync(
+    join(AGENT_DIR, "config", "agent.json"),
+    JSON.stringify({ firstName: "Nova", lastName: "Vale", slackMemberId: "U09NOVA" }),
+  );
+  writeFileSync(join(AGENT_DIR, "config", "plan.yaml"), PLAN);
+  daemon = await import("./agent-daemon.mjs");
+  responder = await import("./responder.mjs");
+});
+
+beforeEach(() => {
+  for (const rel of [["state", "execution"], ["state", "queues"], ["state", "inbox"], ["state", "locks"], ["logs", "daemon"]]) {
+    rmSync(join(AGENT_DIR, ...rel), { recursive: true, force: true });
+  }
+  if (daemon) daemon._resetLadderCaches();
+  delete process.env.DAEMON_EXECUTION_LADDER;
+});
+
+// --- helpers ---------------------------------------------------------------
+
+function writeLive(item, service) {
+  const dir = join(AGENT_DIR, "state", "inbox", service);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${item.id}.json`), JSON.stringify(item));
+}
+
+/** Fakes for exactly the network / subprocess boundary. Nothing else. */
+function spy(classResult) {
+  const seen = { classify: 0, quick: [], dispatch: [], holding: 0 };
+  return {
+    seen,
+    deps: {
+      classify: async () => {
+        seen.classify += 1;
+        return classResult;
+      },
+      sendQuickResponse: async (item, _cr, routed) => {
+        seen.quick.push({ id: item.id, rung: routed ? routed.rung : null });
+        return { sent: true, text: "ack", via: "fake" };
+      },
+      sendHoldingMessage: async () => {
+        seen.holding += 1;
+        return { sent: false, holdingText: null };
+      },
+      dispatch: (_p, item, _cr, _s, opts) => {
+        seen.dispatch.push({ id: item.id, execution: item.execution || null });
+        opts.onClose({ ok: true, code: 0 });
+      },
+    },
+  };
+}
+
+function journal() {
+  const p = join(AGENT_DIR, "state", "execution", "journal.jsonl");
+  if (!existsSync(p)) return [];
+  return readFileSync(p, "utf-8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l));
+}
+
+const decisions = () => journal().filter((r) => r.event === "decision");
+const outcomes = () => journal().filter((r) => r.event === "outcome");
+
+function dm(over = {}) {
+  return {
+    id: "MSG-DM",
+    raw_ref: "slack:D77:1",
+    channel: "dm/priya",
+    channel_id: "D77",
+    sender: "Priya Raman",
+    sender_id: "U_PRIYA",
+    content: "can you confirm the deadline?",
+    timestamp: new Date().toISOString(),
+    ...over,
+  };
+}
+
+const RESPOND = {
+  priority: "normal",
+  action: "respond",
+  model: "sonnet",
+  summary: "deadline question",
+  category: "action_required",
+  directed_at_agent: true,
+};
+
+// ---------------------------------------------------------------------------
+// 1) A DM goes THROUGH the ladder — and is still answered exactly as before.
+// ---------------------------------------------------------------------------
+
+test("LADDER: a DM is journalled intake→match→route→outcome AND still quick-replies", async () => {
+  const item = dm();
+  writeLive(item, "slack");
+  const s = spy(RESPOND);
+  await daemon.processItem(item, "slack", s.deps);
+
+  const d = decisions();
+  assert.equal(d.length, 1, "one decision row");
+  assert.equal(d[0].surface, "dm");
+  assert.equal(d[0].disposition, "react_now");
+  assert.equal(d[0].reason, "directed_now");
+  assert.equal(d[0].obligationKey, "react.message.dm", "match bound the DM to the plan's REACT obligation");
+  assert.equal(d[0].rung, 0, "route chose rung 0 — one protocol method with the params in hand");
+  assert.equal(d[0].mechanism, "tool-surface");
+  assert.ok(d[0].why.some((w) => w.includes("single method messaging.send")), "the why records the rung reasoning");
+
+  const o = outcomes();
+  assert.equal(o.length, 1);
+  assert.equal(o[0].effect, "react", "the react effect ran");
+  assert.equal(o[0].ok, true);
+  assert.equal(o[0].spoke, true, "the agent spoke, so the ping-pong chain deepens");
+  assert.equal(o[0].ref.path, "quick_reply", "the effect drove the daemon's real quick-reply path");
+
+  // NO REGRESSION: the classifier ran and the reply was sent.
+  assert.equal(s.seen.classify, 1, "the Haiku classifier still ran for a directed DM");
+  assert.deepEqual(s.seen.quick, [{ id: "MSG-DM", rung: 0 }], "the quick reply was sent, carrying its rung");
+  assert.equal(s.seen.dispatch.length, 0, "no session spawned for a rung-0 reply");
+});
+
+// ---------------------------------------------------------------------------
+// 2) A board task is WORK: it queues, and never reaches the classifier.
+// ---------------------------------------------------------------------------
+
+test("LADDER: an assigned board task is queued to state/queues/inbound.yaml, not answered", async () => {
+  const task = {
+    id: "cohort-task_assigned-149",
+    raw_ref: "cohort:task_assigned:cmql3j5j301jwhhv2ipp8gmir:149",
+    service: "cohort",
+    kind: "task_assigned",
+    sender: "Priya Raman",
+    sender_id: "mem_priya_0002",
+    content: "Ship the Q3 revenue reconciliation",
+    channel_id: "board_main",
+    timestamp: new Date().toISOString(),
+  };
+  writeLive(task, "cohort");
+  const s = spy(RESPOND);
+  await daemon.processItem(task, "cohort", s.deps);
+
+  const d = decisions()[0];
+  assert.equal(d.surface, "task_assigned");
+  assert.equal(d.disposition, "schedule");
+  assert.equal(d.reason, "not_respondable", "a board assignment is work, not conversation");
+  assert.equal(d.obligationKey, "react.task.assigned");
+  assert.equal(d.rung, 3, "no lower predicate holds for open work → a bounded session");
+
+  const o = outcomes()[0];
+  assert.equal(o.effect, "schedule");
+  assert.equal(o.ok, true);
+
+  // The queue row is real, and it is the file `sweepBacklog` already reads.
+  const q = readFileSync(join(AGENT_DIR, "state", "queues", "inbound.yaml"), "utf-8");
+  assert.match(q, /id: "inb-board\.task_assigned#149"/);
+  assert.match(q, /rung: 3/);
+  assert.match(q, /obligation_key: "react\.task\.assigned"/);
+  assert.match(q, /why: ".*not a conversational surface/, "the reasoning travels with the work");
+
+  assert.equal(s.seen.classify, 0, "no Haiku call — the ladder placed it without one");
+  assert.equal(s.seen.quick.length, 0);
+  assert.equal(s.seen.dispatch.length, 0);
+});
+
+// ---------------------------------------------------------------------------
+// 3) `ignore` is first-class: journalled, cheap, and it does not call Haiku.
+// ---------------------------------------------------------------------------
+
+test("LADDER: ambient channel chatter is IGNORED, with a journalled reason, and costs no classifier call", async () => {
+  const ambient = {
+    id: "MSG-AMBIENT",
+    raw_ref: "slack:C90:1",
+    channel: "#engineering",
+    channel_id: "C90",
+    sender: "Tomas Lind",
+    sender_id: "U_TOMAS",
+    content: "lunch anyone",
+    timestamp: new Date().toISOString(),
+  };
+  writeLive(ambient, "slack");
+  const s = spy(RESPOND);
+  await daemon.processItem(ambient, "slack", s.deps);
+
+  const d = decisions()[0];
+  assert.equal(d.disposition, "ignore");
+  assert.equal(d.reason, "ambient_channel");
+  assert.ok(d.why.some((w) => w.includes("park for the ambient sweep")), "the ignore explains itself");
+
+  const o = outcomes()[0];
+  assert.equal(o.effect, "none", "an ignore is a completed decision with no effect");
+  assert.equal(o.ok, true, "an ignore is a SUCCESS, not a failure");
+  assert.equal(o.spoke, false);
+
+  assert.equal(s.seen.classify, 0, "an ambient message no longer costs a Haiku call");
+  assert.equal(s.seen.quick.length, 0);
+  assert.equal(s.seen.dispatch.length, 0);
+
+  // It is finished with, not left to be re-polled forever.
+  const files = readdirSync(join(AGENT_DIR, "state", "inbox", "slack"));
+  assert.deepEqual(files, ["MSG-AMBIENT.json.processed"]);
+});
+
+// ---------------------------------------------------------------------------
+// 4) REQUIREMENT: an event no obligation covers still reaches today's path.
+// ---------------------------------------------------------------------------
+
+test("LADDER: an event no obligation covers is still answered, capped at rung ≤1, and proposes the missing obligation", async () => {
+  rmSync(join(AGENT_DIR, "config", "plan.yaml"), { force: true });
+  daemon._resetLadderCaches();
+  try {
+    const item = dm({ id: "MSG-DM-UNCOVERED", raw_ref: "slack:D78:1", channel_id: "D78" });
+    writeLive(item, "slack");
+    const s = spy(RESPOND);
+    await daemon.processItem(item, "slack", s.deps);
+
+    const d = decisions()[0];
+    assert.equal(d.disposition, "react_now", "an uncovered event is still answered");
+    assert.equal(d.obligationKey, null, "…but it is recorded as uncovered");
+    assert.ok(d.rung <= 1, `uncovered work is capped at rung ≤1, got ${d.rung}`);
+    assert.ok(
+      d.why.some((w) => w.includes("no obligation in the compiled plan covers this event")),
+      "the plan gap is stated in the reasoning",
+    );
+    assert.equal(s.seen.quick.length, 1, "the sender still got an answer");
+
+    // §6.1's other half: the gap becomes a proposal, not just a complaint.
+    const proposed = join(AGENT_DIR, "state", "plan", "proposed.jsonl");
+    assert.ok(existsSync(proposed), "an obligation was proposed to cover the gap");
+    assert.match(readFileSync(proposed, "utf-8"), /react\.message\./);
+  } finally {
+    writeFileSync(join(AGENT_DIR, "config", "plan.yaml"), PLAN);
+    daemon._resetLadderCaches();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 5) REGRESSION (live run): the rule override must not defeat the GUARDS.
+// ---------------------------------------------------------------------------
+
+test("LADDER REGRESSION: a redelivered DM is dropped as `duplicate` and is NOT answered twice", async () => {
+  const item = dm({ id: "MSG-DM-DUP", raw_ref: "slack:D79:1", channel_id: "D79" });
+  writeLive(item, "slack");
+
+  const first = spy(RESPOND);
+  await daemon.processItem(item, "slack", first.deps);
+  assert.equal(first.seen.quick.length, 1, "the first delivery is answered");
+
+  // The SSE push and the poll backstop converge — that convergence is the design.
+  const again = { ...item };
+  writeLive(again, "slack");
+  const second = spy(RESPOND);
+  await daemon.processItem(again, "slack", second.deps);
+
+  const d = decisions();
+  assert.equal(d.length, 2);
+  assert.equal(d[1].disposition, "ignore");
+  assert.equal(d[1].reason, "duplicate", "the dedupe guard fired");
+
+  // The bug this encodes: `isDirectedAtAgent` returns true for ANY DM, so
+  // consulting it on every ignore reason made `duplicate` unreachable and the
+  // agent answered both deliveries.
+  assert.equal(second.seen.quick.length, 0, "the redelivery was NOT answered");
+  assert.equal(second.seen.classify, 0, "…and did not even reach the classifier");
+});
+
+// ---------------------------------------------------------------------------
+// 6) …but a directedness MISS must still fall through. Silence is the expensive
+//    failure, so the ladder never has the last word on "is this mine".
+// ---------------------------------------------------------------------------
+
+test("LADDER: a directedness disagreement falls through to the classifier path rather than gagging the agent", async () => {
+  // Ambient by intake's rules (no mention flag, not a DM, not a thread reply),
+  // but the agent's own name is in the text — which `isDirectedAtAgent` catches
+  // and intake does not.
+  const item = {
+    id: "MSG-NAMED",
+    raw_ref: "slack:C91:1",
+    channel: "#engineering",
+    channel_id: "C91",
+    sender: "Tomas Lind",
+    sender_id: "U_TOMAS",
+    content: "nova can you take the reconciliation?",
+    timestamp: new Date().toISOString(),
+  };
+  writeLive(item, "slack");
+  const s = spy(RESPOND);
+  const gate = await daemon.runExecutionLadder(item, "slack", item.raw_ref, "trace-x", s.deps);
+
+  assert.equal(gate.handled, false, "the ladder did not take responsibility");
+  assert.equal(gate.reason, "rule_override");
+  assert.equal(decisions()[0].disposition, "ignore", "the ignore is still journalled — the disagreement is on record");
+});
+
+// ---------------------------------------------------------------------------
+// 7) The rung is a VETO on the quick path, never a promotion.
+// ---------------------------------------------------------------------------
+
+test("RUNG: the quick-reply responder accepts rungs 0-1 and refuses 2+", async () => {
+  assert.equal(responder.rungPermitsQuickReply(null), true, "no routing decision → today's behaviour");
+  assert.equal(responder.rungPermitsQuickReply({ rung: 0 }), true);
+  assert.equal(responder.rungPermitsQuickReply({ rung: 1 }), true);
+  assert.equal(responder.rungPermitsQuickReply({ rung: 2 }), false);
+  assert.equal(responder.rungPermitsQuickReply({ rung: 3 }), false);
+  assert.equal(responder.rungPermitsQuickReply({ rung: 5 }), false, "no subagent-fanout mechanism exists here");
+
+  // A veto, not a promotion: rung 0 does not make research quick-repliable.
+  assert.equal(responder.isQuickReply({ action: "research", priority: "normal", model: "sonnet" }, { rung: 0 }), false);
+  assert.equal(responder.isQuickReply({ action: "respond", priority: "normal", model: "sonnet" }, { rung: 0 }), true);
+  assert.equal(
+    responder.isQuickReply({ action: "respond", priority: "normal", model: "sonnet" }, { rung: 3 }),
+    false,
+    "a rung-3 answer needs a session even when the classifier called it simple",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 8) REGRESSION (live run): with no need estimate every DM routed to rung 3,
+//    which vetoed the quick reply and spawned a session for a two-line message.
+// ---------------------------------------------------------------------------
+
+test("LADDER REGRESSION: the need estimate marks a resolvable reply target as params-known", () => {
+  assert.equal(daemon.ladderNeed({ channel_id: "D1" }).paramsKnown, true, "a resolvable channel → rung 0 is available");
+  assert.equal(daemon.ladderNeed({ raw_ref: "cohort:dm:x:1" }).paramsKnown, true);
+  assert.equal(
+    daemon.ladderNeed({ sender: "someone" }).paramsKnown,
+    false,
+    "no resolvable target → params are NOT known and the ladder walks up to a session that can find it",
+  );
+  assert.equal(daemon.ladderNeed({ channel_id: "D1" }).steps, 1);
+});
+
+// ---------------------------------------------------------------------------
+// 9) The escape hatch preserves the old behaviour exactly — and says so.
+// ---------------------------------------------------------------------------
+
+test("LADDER: DAEMON_EXECUTION_LADDER=0 restores the pre-ladder path and warns about what goes dark", async () => {
+  process.env.DAEMON_EXECUTION_LADDER = "0";
+  daemon._resetLadderCaches();
+  const warnings = [];
+  const realWarn = console.warn;
+  console.warn = (...a) => warnings.push(a.join(" "));
+  try {
+    const item = dm({ id: "MSG-DM-OFF", raw_ref: "slack:D80:1", channel_id: "D80" });
+    writeLive(item, "slack");
+    const s = spy(RESPOND);
+    await daemon.processItem(item, "slack", s.deps);
+
+    assert.equal(journal().length, 0, "nothing is journalled with the ladder off");
+    assert.equal(s.seen.classify, 1, "the classifier path is untouched");
+    assert.equal(s.seen.quick.length, 1, "the DM is still answered");
+    assert.ok(
+      warnings.some((w) => w.includes("DAEMON_EXECUTION_LADDER=0") && w.includes("no record of what was ignored")),
+      "turning it off is never silent",
+    );
+  } finally {
+    console.warn = realWarn;
+    delete process.env.DAEMON_EXECUTION_LADDER;
+  }
+});

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

@@ -241,3 +241,72 @@ test("the guard never throws, whatever it is handed", async () => {
   assert.equal(typeof r.ok, "boolean");
   assert.equal(r.cadence, "goal-steward");
 });
+
+// ---------------------------------------------------------------------------
+// THE SENSOR REGISTRY — the joint that made every KPI unmeasurable
+// ---------------------------------------------------------------------------
+
+test("the guard BUILDS the sensor registry and hands it to the loop", async () => {
+  const root = makeRoot();
+  try {
+    let got = null;
+    await guardGoalSteward(
+      { event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} },
+      seams({ runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; } }),
+    );
+    assert.ok(got, "the loop ran");
+    assert.equal(typeof got.sensors, "object", "run() must receive a sensor registry");
+    // Real, executable sensors — not an empty object. Without this every
+    // objective returns {ok:false,"no-implementation"} and D3 can never admit.
+    assert.equal(typeof got.sensors.board_ready, "function");
+    assert.equal(typeof got.sensors.decision_list, "function");
+    assert.equal(typeof got.sensors.email_inbox, "function");
+    // …including a named refusal for every capability the derivation can pick.
+    assert.equal(typeof got.sensors.task_update, "function");
+  } finally { cleanup(root); }
+});
+
+test("a missing capability manifest passes reachable=undefined, NOT an empty set", async () => {
+  const root = makeRoot();
+  try {
+    let got = null;
+    await guardGoalSteward(
+      { event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} },
+      seams({ runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; } }),
+    );
+    // measureKpi only enforces reachability when it is defined; an empty Set
+    // here would silently refuse every objective in the fleet.
+    assert.equal(got.reachable, undefined);
+  } finally { cleanup(root); }
+});
+
+test("the caller's sensors win — the registry is an override, not a mandate", async () => {
+  const root = makeRoot();
+  try {
+    let got = null;
+    const mine = { board_ready: async () => ({ value: 1 }) };
+    await guardGoalSteward(
+      { event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} },
+      seams({ sensors: mine, reachable: new Set(["board_ready"]),
+        runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; } }),
+    );
+    assert.equal(got.sensors, mine);
+    assert.ok(got.reachable.has("board_ready"));
+  } finally { cleanup(root); }
+});
+
+test("a registry that cannot be built is LOUD, and the loop still runs", async () => {
+  const root = makeRoot();
+  const logs = [];
+  try {
+    let got = null;
+    await guardGoalSteward(
+      { event: { cadence: "goal-steward" }, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) },
+      seams({
+        // A poisoned root: resolveAgentRoot of a non-string throws inside the builder.
+        runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; },
+      }),
+    );
+    assert.ok(got, "the guard never blocks the loop on a registry failure");
+  } finally { cleanup(root); }
+});

package/scripts/daemon/maestro-daemon.mjs

@@ -227,6 +227,59 @@ try {
   console.warn(`[DAEMON] org-mesh init failed (running standalone): ${err.message}`);
 }
 
+// ---------------------------------------------------------------------------
+// 3b''. Org PUSH channel (delivery)
+// ---------------------------------------------------------------------------
+// Time-to-notice, not a new ingestion route.
+//
+// Until now the ONLY way an org event reached this daemon was the 45s
+// `messaging-inbound` cadence, so a human who @mentions an AI colleague waited
+// up to three quarters of a minute — and hq had already gone quiet on their
+// behalf (it suppresses its own in-process responder for any member whose daemon
+// beat within 100s, hq 4d762d30). hq ships the delivery half at
+// `GET /api/v1/stream` (SSE, per-seat filtered) with `agent.wait` as a bounded
+// long-poll fallback; NOTHING in this repo consumed either. This is the consumer.
+//
+// The ladder is STREAM → LONGPOLL → CADENCE and the bottom rung is the existing
+// 45s cadence, which is never disabled: a push frame is a HINT ("something
+// happened at seq N — go look"), and the authoritative, ACL'd, cursor-guarded
+// pull is still `guardMessagingInbound` → `pullWideInbound`. So a dropped frame
+// is not lost work, a duplicate frame is dedup-guarded, and a push channel that
+// dies entirely degrades the agent to exactly today's behaviour.
+//
+// Fully fail-open, never silent, and NEVER takes the daemon down.
+// Kill switch: COHORT_PUSH_DISABLED=1.
+try {
+  const { connectOrgPush } = await import("../../lib/org/push.mjs");
+  const { loadOrgConfig } = await import("../../lib/org/client.mjs");
+  const cfg = loadOrgConfig(AGENT_DIR);
+
+  // The seat id. Used ONLY to suppress this agent's own echoes — hq already
+  // filters delivery to the seat bound to the API key, so this is belt-and-
+  // braces, not the ACL.
+  const selfIds = [
+    process.env.COHORT_AGENT_ID,
+    cfg && cfg.org && cfg.org.cohort ? cfg.org.cohort.agentId : null,
+  ].filter(Boolean);
+
+  const orgPush = await connectOrgPush({ agentRoot: AGENT_DIR, cfg, selfIds });
+  if (orgPush && orgPush.isEnabled) {
+    console.log(`[DAEMON] org-push connected (rung: ${orgPush.rung()}) — the 45s messaging-inbound cadence remains the safety net`);
+  } else {
+    console.log("[DAEMON] org-push inert (org integration disabled or COHORT_PUSH_DISABLED=1) — inbound arrives on the 45s cadence only");
+  }
+  const stopPush = (sig) => {
+    try { orgPush.stop(); } catch { /* ignore */ }
+    if (orgPush && orgPush.isEnabled) console.log(`[DAEMON] org-push stopped (${sig})`);
+  };
+  process.on("SIGTERM", () => stopPush("SIGTERM"));
+  process.on("SIGINT", () => stopPush("SIGINT"));
+} catch (err) {
+  // A push failure must cost latency, never delivery. Say which, so nobody
+  // reads a slow agent as a broken one.
+  console.warn(`[DAEMON] org-push init failed (${err.message}) — inbound still arrives on the 45s messaging-inbound cadence, just not instantly`);
+}
+
 // ---------------------------------------------------------------------------
 // 3c. Model router config validation (1.12.0+, advisory)
 // ---------------------------------------------------------------------------

package/scripts/daemon/prompt-builder.mjs

@@ -344,6 +344,25 @@ Why split read vs write: MCP tools are ideal for reading because they have full
 - Set appropriate priority, owner, SLA deadline, and next_action
 - Log the queuing decision`,
 
+  // `queue` is what an INBOX turn does when it decides work should wait. It is
+  // the wrong instruction for a BACKLOG turn, which exists because the waiting
+  // is over — and yet `sweepBacklog` sent `action:"queue"` on every row it
+  // drained, so every drained session was told "this item needs tracking but
+  // not immediate action". A calendar invite traced end-to-end reached a
+  // perfectly addressable row naming `calendar.rsvp` and the meeting id, and
+  // was then instructed to file it. Nothing ever RSVP'd, and nothing logged a
+  // failure, because re-queueing IS what the session was asked for.
+  execute: `ACTION: Do the queued work now.
+- The waiting is over: this row was queued earlier and the drain has picked it up
+- Read "Next action required" and the Context block above — they name the record
+  (Entity) and, where the surface knows it, the method (Suggested method)
+- Take the action. Prefer the suggested method; override it when the context
+  plainly calls for something else, and say why
+- If the action is blocked (missing permission, missing parameter, needs a human),
+  say exactly what blocks it and mark the item blocked — do NOT silently re-queue
+- Update the queue item status to "resolved" (or "blocked") when done, with a
+  one-line history entry saying what you actually did`,
+
   archive: `ACTION: Archive — no action needed.
 - Mark this item as processed
 - Log that it was reviewed and archived with a brief reason
@@ -515,6 +534,34 @@ function buildBacklogContext(queueItem) {
   lines.push(`Owner: ${queueItem.owner || loadAgent().firstName.toLowerCase()}`);
   if (queueItem.source) lines.push(`Source: ${queueItem.source}`);
   if (queueItem.source_ref) lines.push(`Source ref: ${queueItem.source_ref}`);
+  // ── what to act ON, and with WHAT ────────────────────────────────────────
+  // `lib/execution/effects.scheduleToQueue` writes these; `parseQueueItems`
+  // reads them back. They are the whole difference between a session that can
+  // RSVP the invite it was woken for and one that was handed an event key
+  // built from a ledger seq and no method. Both optional.
+  if (queueItem.entity_id) lines.push(`Entity: ${queueItem.entity_id} (the record this work acts on)`);
+  if (Array.isArray(queueItem.uses) && queueItem.uses.length > 0) {
+    lines.push(`Suggested method: ${queueItem.uses.join(", ")} (the surface's own answer — override it if the context says otherwise)`);
+  }
+  // ── Why this item exists (goal-steward provenance) ────────────────────────
+  // `lib/goals/loop.renderQueueItems` writes `advances` / `expected_delta` /
+  // `obligation_key` / `rung` onto every item a measured KPI gap produced, and
+  // `lib/backlog.parseQueueItems` now reads all four back. Without them here the
+  // session sees only "Close the on_time_rate gap: raise from 75 toward 95" and
+  // has no idea which objective it is accountable to, by how much, or how big a
+  // move was budgeted — so it cannot report an outcome the intervention ledger
+  // can score. This block is the difference between a task and a commitment.
+  if (Array.isArray(queueItem.advances) && queueItem.advances.length > 0) {
+    lines.push(`Advances objective: ${queueItem.advances.join(", ")}`);
+  }
+  if (queueItem.obligation_key) lines.push(`Obligation: ${queueItem.obligation_key}`);
+  if (Number.isFinite(queueItem.expected_delta)) {
+    lines.push(`Expected delta: ${queueItem.expected_delta} (this is what the KPI is expected to move by)`);
+  }
+  if (queueItem.disposition) lines.push(`Staffing: ${queueItem.disposition}`);
+  if (Number.isFinite(queueItem.rung)) {
+    lines.push(`Execution rung: ${queueItem.rung}${queueItem.mechanism ? ` (${queueItem.mechanism})` : ""}`);
+  }
   if (queueItem.due) lines.push(`Due: ${queueItem.due}`);
   if (queueItem.sla_deadline) lines.push(`SLA deadline: ${queueItem.sla_deadline}`);
   lines.push("");