@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/execution/match.test.mjs

@@ -1,235 +0,0 @@
-/**
- * lib/execution/match.test.mjs — binding events to the compiled plan.
- *
- * The negatives here are the ones that keep the plan honest: a suspended
- * obligation must NOT bind (and must not look like a coverage gap either), an
- * unparseable predicate must fail closed rather than matching everything, and an
- * event genuinely nobody planned for must produce a proposal the schema accepts.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  matchObligation,
-  proposeReact,
-  reactObligations,
-  kindAliases,
-  evalPredicate,
-  predicateView,
-  loadReactObligations,
-  PREDICATE_FIELDS,
-} from "./match.mjs";
-import { validateObligation } from "../plan/schema.mjs";
-import { fromInboxItem } from "./intake.mjs";
-import { decide } from "./disposition.mjs";
-
-const ME = "mem_self";
-
-function ob(over = {}) {
-  return {
-    key: "react.task.assigned",
-    kind: "REACT",
-    source: { origin: "react-standard" },
-    trigger: { topic: "task", kind: "assigned", predicate: null },
-    status: "active",
-    uses: [],
-    allowed_tools: [],
-    action_classes: [],
-    offline_safe: true,
-    ...over,
-  };
-}
-
-function boardEvent() {
-  return {
-    candidate: {
-      seq: 90,
-      family: "board",
-      kind: "assigned",
-      entityId: "task_1",
-      actor: "mem_peer",
-      at: "2026-08-11T09:00:00.000Z",
-      topic: "task",
-      surfaces: ["task_assigned"],
-      ids: { taskId: "task_1", channelId: "chan_1" },
-      directTo: [ME],
-      payload: {},
-    },
-    verdict: { directed: true, surface: "task_assigned", reason: "assignee" },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// aliases + predicates
-// ---------------------------------------------------------------------------
-
-test("kind aliases bridge chain coordinates and surface names", () => {
-  const a = kindAliases({ kind: "assigned" }, { surface: "task_assigned" });
-  assert.ok(a.includes("assigned"));
-  assert.ok(a.includes("task_assigned"));
-  // The reconstructed-from-disk form must reach the same obligation.
-  const b = kindAliases({ kind: "task_assigned" }, { surface: "task_assigned" });
-  assert.ok(b.includes("assigned"), "an event rebuilt from a flattened item must still bind");
-});
-
-test("a predicate matches on a known field, including any-of lists", () => {
-  const view = predicateView({ actor: "mem_peer", topic: "task" }, { surface: "task_assigned", reason: "assignee" });
-  assert.equal(evalPredicate(null, view).ok, true);
-  assert.equal(evalPredicate({}, view).ok, true);
-  assert.equal(evalPredicate({ surface: "task_assigned" }, view).ok, true);
-  assert.equal(evalPredicate({ reason: ["assignee", "reviewer"] }, view).ok, true);
-  assert.equal(evalPredicate({ reason: "reviewer" }, view).ok, false);
-});
-
-test("NEGATIVE: a predicate this module cannot evaluate FAILS CLOSED", () => {
-  const view = predicateView({}, {});
-  const unknown = evalPredicate({ mood: "urgent" }, view);
-  assert.equal(unknown.ok, false, "an unknown field must not be ignored — that would widen the obligation");
-  assert.ok(unknown.why.includes("mood"));
-  assert.equal(evalPredicate("reason=mention", view).ok, false, "a string predicate is not a field map");
-  assert.equal(evalPredicate([{ surface: "dm" }], view).ok, false);
-  for (const f of PREDICATE_FIELDS) assert.equal(evalPredicate({ [f]: "" }, view).ok, true, `${f} should compare blank-to-blank`);
-});
-
-// ---------------------------------------------------------------------------
-// matching
-// ---------------------------------------------------------------------------
-
-test("an event binds the obligation whose trigger covers it", () => {
-  const r = matchObligation({ ...boardEvent(), plan: [ob()] });
-  assert.equal(r.obligation.key, "react.task.assigned");
-  assert.ok(r.why.join(" ").includes("bound to react.task.assigned"));
-});
-
-test("a trigger may be written against the surface as well as the coarse topic", () => {
-  const r = matchObligation({ ...boardEvent(), plan: [ob({ key: "react.surface", trigger: { topic: "task_assigned", kind: null } })] });
-  assert.equal(r.obligation.key, "react.surface");
-});
-
-test("the most specific match wins, deterministically", () => {
-  const broad = ob({ key: "react.task.any", trigger: { topic: "task", kind: null, predicate: null } });
-  const narrow = ob({ key: "react.task.assigned", trigger: { topic: "task", kind: "assigned", predicate: { reason: "assignee" } } });
-  const a = matchObligation({ ...boardEvent(), plan: [broad, narrow] });
-  const b = matchObligation({ ...boardEvent(), plan: [narrow, broad] });
-  assert.equal(a.obligation.key, "react.task.assigned");
-  assert.equal(b.obligation.key, a.obligation.key, "input order must not change the binding");
-  assert.ok(a.why.some((w) => w.includes("also matched, less specific")));
-});
-
-test("NEGATIVE: a suspended obligation does not bind, and does not read as a coverage gap", () => {
-  const r = matchObligation({ ...boardEvent(), plan: [ob({ status: "suspended" })] });
-  assert.equal(r.obligation, null);
-  assert.deepEqual(r.suspended.map((x) => x.key), ["react.task.assigned"]);
-  assert.ok(r.why.join(" ").includes('status "suspended"'), "the reason must distinguish suspended from uncovered");
-});
-
-test("NEGATIVE: a proposed obligation is not bindable either", () => {
-  const r = matchObligation({ ...boardEvent(), plan: [ob({ status: "proposed" })] });
-  assert.equal(r.obligation, null);
-});
-
-test("NEGATIVE: an undirected event is never matched", () => {
-  const r = matchObligation({
-    candidate: boardEvent().candidate,
-    verdict: { directed: false, reason: "ambient_channel", surface: null },
-    plan: [ob({ trigger: { topic: "task", kind: null } })],
-  });
-  assert.equal(r.obligation, null);
-  assert.ok(r.why[0].includes("no directed event"));
-});
-
-test("NEGATIVE: a plan with no REACT obligations says so rather than failing silently", () => {
-  const r = matchObligation({ ...boardEvent(), plan: [{ key: "schedule.x", kind: "SCHEDULE" }] });
-  assert.equal(r.obligation, null);
-  assert.ok(r.why.join(" ").includes("no REACT obligations"));
-});
-
-test("SCHEDULE and OUTCOME obligations are never considered for an inbound event", () => {
-  const list = reactObligations({ obligations: [ob(), { key: "outcome.x", kind: "OUTCOME" }, { key: "schedule.x", kind: "SCHEDULE" }] });
-  assert.deepEqual(list.map((x) => x.key), ["react.task.assigned"]);
-});
-
-// ---------------------------------------------------------------------------
-// binding changes the decision
-// ---------------------------------------------------------------------------
-
-test("binding an obligation lifts the rung cap the uncovered path imposes", () => {
-  const ev = boardEvent();
-  const need = { steps: 8, filesystem: true };
-  const uncovered = decide({ ...ev, me: ME, history: null, need });
-  const covered = decide({
-    ...ev,
-    me: ME,
-    history: null,
-    need,
-    obligation: ob({ objective_id: "obj_1" }),
-  });
-  assert.ok(uncovered.rung <= 1, "an uncovered event must be capped at rung ≤1");
-  assert.ok(covered.rung > uncovered.rung, "a planned event may route to the rung the work actually needs");
-  assert.equal(covered.obligationKey, "react.task.assigned");
-  assert.ok(uncovered.drift && uncovered.drift.kind === "uncovered_event");
-});
-
-// ---------------------------------------------------------------------------
-// proposals
-// ---------------------------------------------------------------------------
-
-test("an uncovered event proposes a schema-valid REACT obligation", () => {
-  const ev = boardEvent();
-  const p = proposeReact({ ...ev, tier: "T0" });
-  assert.ok(p.obligation, p.why);
-  assert.deepEqual(validateObligation(p.obligation), [], "the proposal must satisfy the real schema");
-  assert.equal(p.obligation.status, "proposed", "nothing an agent proposes is active");
-  assert.deepEqual(p.obligation.uses, [], "an unprobed proposal may not cite a capability (§5.1)");
-  assert.equal(p.obligation.trigger.topic, "task");
-});
-
-test("a proposal inherits the surface's blast radius, so email proposals are external", () => {
-  const norm = fromInboxItem(
-    { raw_ref: "cohort:email:mail_1:5", kind: "email", service: "cohort", timestamp: "2026-08-11T09:00:00.000Z", content: "hi", priority_signals: {} },
-    { me: ME },
-  );
-  const p = proposeReact({ candidate: norm.candidate, verdict: norm.verdict, tier: "T0" });
-  assert.ok(p.obligation.action_classes.includes("external"));
-  assert.equal(p.obligation.offline_safe, false);
-});
-
-test("a proposal that would be invalid is dropped loudly, never written", () => {
-  const p = proposeReact({ candidate: {}, verdict: {} });
-  assert.equal(p.obligation, null);
-  assert.ok(p.errors.length > 0);
-});
-
-test("proposed keys are stable slugs, so the same gap proposes the same obligation twice", () => {
-  const ev = boardEvent();
-  const a = proposeReact({ ...ev, tier: "T0" });
-  const b = proposeReact({ ...ev, tier: "T1" });
-  assert.equal(a.obligation.key, b.obligation.key);
-  assert.match(a.obligation.key, /^[a-z0-9][a-z0-9._-]*$/);
-});
-
-// ---------------------------------------------------------------------------
-// loading
-// ---------------------------------------------------------------------------
-
-test("a missing plan.yaml degrades with a reason instead of throwing", async () => {
-  const r = await loadReactObligations("/nonexistent/agent/root");
-  assert.deepEqual(r.obligations, []);
-  assert.equal(r.degraded, true);
-  assert.ok(r.reason, "a degradation must always carry a reason");
-});
-
-test("a plan is read through the one loader, and its REACT obligations come back", async () => {
-  const plan = {
-    enforcement: "observe_only",
-    obligations: [ob(), { key: "schedule.a", kind: "SCHEDULE" }],
-  };
-  const r = await loadReactObligations("/anywhere", {
-    readPlan: () => plan,
-    yaml: { load: () => plan },
-  });
-  assert.equal(r.degraded, false);
-  assert.equal(r.enforcement, "observe_only");
-  assert.deepEqual(r.obligations.map((x) => x.key), ["react.task.assigned"]);
-});

package/lib/execution/pipeline.test.mjs

@@ -1,392 +0,0 @@
-/**
- * pipeline.test.mjs — the one call the inbox pipeline makes, end to end.
- * Run: node --test lib/execution/pipeline.test.mjs
- *
- * What is actually under test here is the BATCH behaviour, because that is the
- * part a caller re-implementing the loop would get wrong: the same event
- * arriving twice inside one sweep (SSE push + poll backstop, which is the
- * design), a burst from one actor, and a human speaking mid-batch.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { processInbound, processOne, batchHistory } from "./pipeline.mjs";
-import { JOURNAL_REL } from "./journal.mjs";
-import { INBOUND_QUEUE_REL, PROPOSED_REL } from "./effects.mjs";
-
-const ME = "mem_self";
-const NOW = Date.parse("2026-08-11T12:00:00Z");
-
-function tmp() {
-  return mkdtempSync(join(tmpdir(), "exec-pipeline-"));
-}
-
-/** A recording effect set — no network, every call captured. */
-function fakeEffects() {
-  const calls = { react: [], schedule: [], delegate: [], escalate: [], drift: [], propose: [], obligation: [], arbitrate: [] };
-  return {
-    calls,
-    react: async (a) => { calls.react.push(a); return { ok: true, ref: { sent: true } }; },
-    schedule: async (a) => { calls.schedule.push(a); return { ok: true, ref: { queued: true } }; },
-    delegate: async (a) => { calls.delegate.push(a); return { ok: true, ref: {} }; },
-    escalate: async (a) => { calls.escalate.push(a); return { ok: true, ref: {} }; },
-    arbitrate: async (a) => { calls.arbitrate.push(a); return { ok: true, ref: { granted: true } }; },
-    reportDrift: async (a) => { calls.drift.push(a); return { ok: true }; },
-    propose: async (a) => { calls.propose.push(a); return { ok: true }; },
-    proposeObligation: async (a) => { calls.obligation.push(a); return { ok: true }; },
-  };
-}
-
-function dm(over = {}) {
-  return {
-    id: "cohort-msg_1",
-    service: "cohort",
-    channel: "dm",
-    channel_id: "chan_dm",
-    sender: "peer",
-    sender_id: "mem_peer",
-    timestamp: "2026-08-11T11:59:00.000Z",
-    content: "quick question",
-    thread_id: "msg_1",
-    is_dm: true,
-    priority_signals: { mentions_agent: true },
-    raw_ref: "cohort:dm:msg_1:11",
-    kind: "message",
-    ...over,
-  };
-}
-
-const REACT_DM = {
-  key: "react.message.dm",
-  kind: "REACT",
-  source: { origin: "react-standard" },
-  trigger: { topic: "message", kind: null, predicate: null },
-  status: "active",
-  uses: [],
-  allowed_tools: [],
-  action_classes: [],
-  offline_safe: true,
-};
-
-function run(items, over = {}) {
-  return processInbound({
-    items,
-    me: ME,
-    nowMs: NOW,
-    loadPlan: false,
-    obligations: [REACT_DM],
-    ...over,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// the happy path, per surface
-// ---------------------------------------------------------------------------
-
-test("a directed DM is answered, and the journal records both halves", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const { results, stats } = await run([dm()], { agentRoot: root, effects: fx });
-    assert.equal(results[0].decision.disposition, "react_now");
-    assert.equal(results[0].origin, "inbox_item");
-    assert.equal(results[0].obligationKey, "react.message.dm");
-    assert.equal(fx.calls.react.length, 1);
-    assert.equal(stats.acted, 1);
-
-    const journal = readFileSync(join(root, JOURNAL_REL), "utf-8").trim().split("\n").map(JSON.parse);
-    assert.ok(journal.some((r) => r.event === "decision"), "the reasoning is on disk before the effect runs");
-    assert.ok(journal.some((r) => r.event === "outcome"), "and the outcome after it");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("a mixture of surfaces is dispositioned per surface in one batch", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const { stats } = await run(
-      [
-        dm(),
-        dm({ id: "cohort-task-2", raw_ref: "cohort:task_assigned:task_2:12", kind: "task_assigned", is_dm: false, channel_id: "chan_b" }),
-        { id: "daemon_down", severity: "critical", detail: "no beat" },
-        { id: "warm", severity: "info", detail: "warmed" },
-        { id: "s1", service: "slack", channel_id: "C1", content: "unrelated chatter", timestamp: "2026-08-11T11:00:00.000Z", priority_signals: {} },
-      ],
-      { agentRoot: root, effects: fx, obligations: [] },
-    );
-    assert.equal(stats.processed, 5);
-    assert.equal(stats.byDisposition.react_now, 1, "only the DM warrants an immediate answer");
-    assert.equal(stats.byDisposition.schedule, 2, "the task and the critical alert become work");
-    assert.equal(stats.byDisposition.ignore, 2, "the info alert and the ambient channel message do not");
-    assert.equal(stats.bySurface.alert, 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// batch semantics — the reason this module exists
-// ---------------------------------------------------------------------------
-
-test("the same event delivered twice in one batch is answered ONCE", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    // The SSE push and the 300s sweep both deliver; §6.1 says they converge here.
-    const { results, stats } = await run([dm(), dm()], { agentRoot: root, effects: fx });
-    assert.equal(results[0].decision.disposition, "react_now");
-    assert.equal(results[1].decision.disposition, "ignore");
-    assert.equal(results[1].decision.reason, "duplicate");
-    assert.equal(fx.calls.react.length, 1, "the agent must not answer the same message twice");
-    assert.equal(stats.acted, 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("a burst from one actor is batched rather than answered turn-by-turn", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const items = [];
-    for (let i = 0; i < 6; i += 1) {
-      // A burst of @mentions (NOT DMs): a directed 1:1 DM is now exempt from
-      // actor-flood, so flood batching is exercised on a channel surface where
-      // it still applies. `is_dm:false` + mentions_agent → surface "mention".
-      items.push(dm({ id: `cohort-msg_${i}`, raw_ref: `cohort:mention:msg_${i}:${100 + i}`, thread_id: `t_${i}`, channel_id: `c_${i}`, is_dm: false }));
-    }
-    const { results } = await run(items, { agentRoot: root, effects: fx, actorFloodLimit: 3 });
-    const dispositions = results.map((r) => r.decision.disposition);
-    assert.equal(dispositions[0], "react_now");
-    assert.ok(dispositions.includes("schedule"), "the flood limit must downgrade, not silence");
-    assert.ok(
-      results.some((r) => r.decision.reason === "actor_flood"),
-      "and it must say that is why",
-    );
-    // Nothing was dropped: every event still produced a decision.
-    assert.equal(results.length, 6);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("a ping-pong chain stops inside a single batch", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const items = [];
-    for (let i = 0; i < 6; i += 1) {
-      // Same thread, different events, different actors so the flood guard is not
-      // what stops it.
-      items.push(dm({ id: `cohort-p_${i}`, raw_ref: `cohort:dm:p_${i}:${200 + i}`, sender_id: `mem_peer_${i}` }));
-    }
-    const { results } = await run(items, { agentRoot: root, effects: fx });
-    const stopped = results.filter((r) => r.decision.reason === "reply_chain_depth");
-    assert.ok(stopped.length > 0, "an agent talking into a thread forever must stop inside the same sweep");
-    assert.ok(results.filter((r) => r.spoke).length <= 4, "the DM ceiling is 4 turns");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("a human speaking mid-batch unblocks the agent in the SAME sweep", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const items = [];
-    for (let i = 0; i < 5; i += 1) items.push(dm({ id: `cohort-h_${i}`, raw_ref: `cohort:dm:h_${i}:${300 + i}`, sender_id: `mem_peer_${i}` }));
-    const { results } = await run(items, {
-      agentRoot: root,
-      effects: fx,
-      // the fifth item is a human re-entering the conversation
-      isHumanTurn: (it) => it.id === "cohort-h_4",
-    });
-    assert.notEqual(
-      results[4].decision.reason,
-      "reply_chain_depth",
-      "a human turn must reset the chain before the decision that follows it",
-    );
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("batchHistory unions the on-disk snapshot with in-batch decisions", () => {
-  const base = {
-    seen: (k) => k === "on-disk",
-    chainDepth: () => 2,
-    actorActivity: () => 1,
-    failures: () => 3,
-    rows: [],
-    degraded: false,
-    degradedReason: null,
-  };
-  const h = batchHistory(base);
-  assert.equal(h.seen("on-disk"), true);
-  assert.equal(h.seen("fresh"), false);
-  h.note({ key: "fresh", actor: "a", thread: "t" }, true);
-  assert.equal(h.seen("fresh"), true);
-  assert.equal(h.chainDepth("t"), 3, "in-batch turns add to the on-disk count");
-  assert.equal(h.actorActivity("a"), 2);
-  assert.equal(h.failures("k"), 3, "failures come from the journal only");
-  h.humanTurn("t");
-  assert.equal(h.chainDepth("t"), 0, "a human turn masks the stale on-disk count, not just the in-batch one");
-});
-
-test("batchHistory tolerates no base at all, and says the guards are weakened", () => {
-  const h = batchHistory(null);
-  assert.equal(h.seen("x"), false);
-  assert.equal(h.chainDepth("t"), 0);
-  assert.equal(h.degraded, true);
-  assert.ok(h.degradedReason);
-});
-
-// ---------------------------------------------------------------------------
-// coverage, drift and proposals
-// ---------------------------------------------------------------------------
-
-test("an uncovered directed event records drift AND proposes the obligation that would cover it", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const { results, stats } = await run([dm()], { agentRoot: root, effects: fx, obligations: [] });
-    assert.equal(results[0].obligationKey, null);
-    assert.equal(stats.uncovered, 1);
-    assert.equal(fx.calls.drift.length, 1);
-    assert.equal(fx.calls.drift[0].drift.kind, "uncovered_event");
-    assert.equal(fx.calls.obligation.length, 1, "the plan must learn, not just complain");
-    assert.equal(fx.calls.obligation[0].obligation.status, "proposed");
-    assert.deepEqual(stats.proposed, [fx.calls.obligation[0].obligation.key]);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("a suspended obligation is NOT reported as a coverage gap", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const { results } = await run([dm()], {
-      agentRoot: root,
-      effects: fx,
-      obligations: [{ ...REACT_DM, status: "suspended" }],
-    });
-    assert.deepEqual(results[0].suspendedObligations, ["react.message.dm"]);
-    assert.equal(fx.calls.obligation.length, 0, "the plan already covers this — do not propose a duplicate");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("an ignored event never proposes an obligation", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    await run([{ id: "warm", severity: "info" }], { agentRoot: root, effects: fx, obligations: [] });
-    assert.equal(fx.calls.obligation.length, 0, "coverage is only owed for events the agent would act on");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// failure isolation and degradation reporting — never silent
-// ---------------------------------------------------------------------------
-
-test("one poisoned item cannot take the batch down, and it is logged as an error", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const logs = [];
-    const poison = { get service() { throw new Error("boom"); } };
-    const { results, stats } = await run([dm(), poison, dm({ id: "cohort-msg_2", raw_ref: "cohort:dm:msg_2:12", thread_id: "t2", channel_id: "c2" })], {
-      agentRoot: root,
-      effects: fx,
-      log: (lvl, msg) => logs.push([lvl, msg]),
-    });
-    assert.equal(results.length, 3);
-    assert.equal(stats.processed >= 2, true, "the healthy items still processed");
-    // The poisoned item is either caught by intake's own guard or by the batch
-    // guard — either way it produced a decision or an error, and it was LOUD.
-    assert.ok(
-      logs.some(([lvl]) => lvl === "error" || lvl === "warn"),
-      "a degradation must always be logged",
-    );
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("no compiled plan is reported as a degradation, not treated as normal", async () => {
-  const root = tmp();
-  try {
-    const logs = [];
-    const { stats } = await processInbound({
-      items: [dm()],
-      me: ME,
-      agentRoot: root,
-      nowMs: NOW,
-      effects: fakeEffects(),
-      log: (lvl, msg) => logs.push([lvl, msg]),
-    });
-    assert.ok(
-      stats.degraded.some((d) => d.startsWith("plan_unavailable")),
-      "an agent with no plan runs the whole reactive lane at rung ≤1 — the operator must be able to see that",
-    );
-    assert.ok(logs.some(([lvl]) => lvl === "warn"));
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("an empty batch is a no-op that still returns a well-formed summary", async () => {
-  const { results, stats } = await processInbound({ items: [], me: ME });
-  assert.deepEqual(results, []);
-  assert.equal(stats.total, 0);
-  assert.equal(stats.processed, 0);
-});
-
-test("processOne works standalone, with the default on-disk history", async () => {
-  const root = tmp();
-  try {
-    const fx = fakeEffects();
-    const r = await processOne({ item: dm(), me: ME, agentRoot: root, effects: fx, nowMs: NOW, obligations: [REACT_DM] });
-    assert.equal(r.decision.disposition, "react_now");
-    assert.ok(existsSync(join(root, JOURNAL_REL)));
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// the real effects, wired for once, to prove the shapes line up
-// ---------------------------------------------------------------------------
-
-test("the default effects actually write the queue and the proposal files", async () => {
-  const root = tmp();
-  try {
-    const { defaultEffects } = await import("./effects.mjs");
-    const effects = defaultEffects({ agentRoot: root, me: ME, nowMs: NOW });
-    await processInbound({
-      items: [dm({ id: "cohort-task_9", raw_ref: "cohort:task_assigned:task_9:44", kind: "task_assigned", is_dm: false })],
-      me: ME,
-      agentRoot: root,
-      nowMs: NOW,
-      effects,
-      loadPlan: false,
-      obligations: [],
-    });
-    assert.ok(existsSync(join(root, INBOUND_QUEUE_REL)), "queued work must land on the queue the sweep reads");
-    const proposed = readFileSync(join(root, PROPOSED_REL), "utf-8");
-    assert.ok(proposed.includes('"type":"obligation"'), "the proposed obligation must be reviewable on disk");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});