@cohortapp/agent-sdk 2.4.0 → 2.5.0

package/lib/org/doctor.test.mjs

@@ -14,7 +14,7 @@ import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { checkOrgConnectivity } from "./doctor.mjs";
+import { checkOrgConnectivity, checkReactiveLaneWiring } from "./doctor.mjs";
 import { PROTOCOL_VERSION } from "./protocol.mjs";
 
 // Ambient COHORT_* vars must not leak in.
@@ -239,3 +239,75 @@ test("inbound probe FAILS loudly when the server rejects this SDK's params", ()
     rmSync(r, { recursive: true, force: true });
   });
 });
+
+/* ── probe 0: reactive-lane wiring (local, no network) ─────────────────────
+ * REGRESSION — observed live 2026-08-11 on a real seat. The agent repo carried
+ * a CURRENT lib/execution/ and a STALE scripts/daemon/agent-daemon.mjs, so
+ * `maestro-daemon.mjs` (which resolves ./agent-daemon.mjs from the agent's own
+ * dir) ran a build with no `runExecutionLadder` call. The wide inbound was
+ * current to within one ledger row and every event was still answered, so the
+ * agent looked healthy — while intake / obligation-match / rung / journal never
+ * ran at all and state/execution/journal.jsonl stayed empty. Nothing detected
+ * it, because the new build cannot warn about the old one.
+ */
+
+function laneRoot({ daemon, pipeline = true }) {
+  const r = mkdtempSync(join(tmpdir(), "org-doctor-lane-"));
+  if (pipeline) {
+    mkdirSync(join(r, "lib", "execution"), { recursive: true });
+    writeFileSync(join(r, "lib", "execution", "pipeline.mjs"), "export const processOne = () => {};\n");
+  }
+  if (daemon !== undefined) {
+    mkdirSync(join(r, "scripts", "daemon"), { recursive: true });
+    writeFileSync(join(r, "scripts", "daemon", "agent-daemon.mjs"), daemon);
+  }
+  return r;
+}
+
+test("reactive-lane probe FAILS when the daemon copy predates the execution ladder", () => {
+  const r = laneRoot({ daemon: "async function processItemTraced(){ return classifyItem(item); }\n" });
+  const v = checkReactiveLaneWiring(r);
+  assert.equal(v.level, "fail");
+  assert.match(v.msg, /never calls runExecutionLadder/);
+  assert.match(v.msg, /journal\.jsonl will stay empty/);
+  assert.match(v.msg, /upgrade/, "must tell the operator what to DO");
+  rmSync(r, { recursive: true, force: true });
+});
+
+test("reactive-lane probe is OK when the daemon does call the ladder", () => {
+  const r = laneRoot({ daemon: "const gate = await runExecutionLadder(item, service, itemId, trace_id, deps);\n" });
+  const v = checkReactiveLaneWiring(r);
+  assert.equal(v.level, "ok");
+  rmSync(r, { recursive: true, force: true });
+});
+
+test("reactive-lane probe stays silent when the repo is not an agent layout", () => {
+  // No lib/execution → the framework is not vendored here; nothing to compare.
+  const r = laneRoot({ daemon: "whatever\n", pipeline: false });
+  assert.equal(checkReactiveLaneWiring(r), null);
+  // …and no daemon at all is equally not-applicable.
+  const r2 = laneRoot({});
+  assert.equal(checkReactiveLaneWiring(r2), null);
+  rmSync(r, { recursive: true, force: true });
+  rmSync(r2, { recursive: true, force: true });
+});
+
+test("reactive-lane probe fails OPEN (warn, never throw) on an unreadable daemon", () => {
+  const r = laneRoot({ daemon: "runExecutionLadder\n" });
+  const v = checkReactiveLaneWiring(r, {
+    existsSync: () => true,
+    readFileSync: () => { throw new Error("EACCES"); },
+  });
+  assert.equal(v.level, "warn");
+  assert.match(v.msg, /EACCES/, "the cause must be named, not swallowed");
+  rmSync(r, { recursive: true, force: true });
+});
+
+test("checkOrgConnectivity surfaces the lane probe even for an un-enrolled agent", async () => {
+  const r = laneRoot({ daemon: "processItemTraced\n" });
+  const rs = await checkOrgConnectivity({ agentRoot: r, env: {}, fetchImpl: () => { throw new Error("no network"); } });
+  const lane = rs.find((x) => /Reactive lane/.test(x.msg));
+  assert.ok(lane, "the lane probe must run before the not-enrolled short-circuit");
+  assert.equal(lane.level, "fail");
+  rmSync(r, { recursive: true, force: true });
+});

package/lib/org/inbound/directedness.mjs

@@ -335,6 +335,36 @@ export function classifyEvent(ev) {
     };
   }
 
+  // ── calendar: `entityId` is the Meeting id. The payload names the CALENDAR
+  //    OWNER (`calendarMemberId`, on create) or the RSVP'ing member
+  //    (`memberId`, on rsvp) and NOTHING else — `attendeeCount` is a count, by
+  //    design. Attendance is resolved by `calendar.list`, which is ACL'd to the
+  //    acting seat (facts.myEventIds).
+  if (family === "calendar") {
+    const eventId = base.entityId ?? str(p, "eventId", "meetingId");
+    if (!eventId) return null;
+    const owner = str(p, "calendarMemberId");
+    const rsvper = str(p, "memberId");
+    return {
+      ...base,
+      topic: "calendar",
+      surfaces: ["calendar"],
+      ids: {
+        eventId,
+        title: str(p, "title"),
+        startsAt: str(p, "startsAt", "to"),
+        eventKind: str(p, "eventKind"),
+        rsvp: str(p, "rsvp"),
+        channelId: str(p, "channelId"),
+      },
+      // Only the owner is a PAYLOAD-proven address. An RSVP names the person who
+      // responded, which is news to the OWNER, not to that person — so it is
+      // deliberately NOT a directTo (it would deliver every agent its own RSVP).
+      directTo: owner ? [owner] : [],
+      hints: { rsvpBy: rsvper || undefined },
+    };
+  }
+
   // ── email: the one family whose redacted payload already names its seat
   //    (`memberId` = the owning mailbox's member). Unrouted mail
   //    (`memberId: null`) belongs to nobody and is dropped.
@@ -406,6 +436,10 @@ export function resolveDirected(cand, me, facts = {}, opts = {}) {
         return yes(surface, "assignee");
       case "calling":
         return yes(surface, "participant");
+      case "calendar":
+        // The payload can only ever prove OWNERSHIP of the calendar; attendance
+        // comes from the ACL'd read below.
+        return yes(surface, "calendar_owner");
       default:
         return yes(surface, "direct");
     }
@@ -428,11 +462,38 @@ export function resolveDirected(cand, me, facts = {}, opts = {}) {
       return resolveEscalation(cand, meId, facts, on);
     case "approval":
       return resolveApproval(cand, meId, facts, on);
+    case "calendar":
+      return resolveCalendar(cand, meId, facts, on);
     default:
       return no("no_rule");
   }
 }
 
+/**
+ * Calendar. The join is `calendar.list` — hq's own seat-scoped query, which
+ * returns an event when the acting seat OWNS the calendar or appears in
+ * `attendeeRows`, and applies the PERSONAL_RESTRICTED lens floor so a
+ * colleague's private event is absent rather than redacted.
+ *
+ * `myEventIds === null` means the read FAILED. That degrades to "unknown", which
+ * closes the surface rather than opening it — a calendar is a private surface,
+ * and guessing wrong here means an agent reacting to a meeting it is not in.
+ */
+function resolveCalendar(cand, me, facts, on) {
+  if (!on("calendar")) return no("surface_disabled");
+  const mine = facts.myEventIds;
+  if (mine == null) return no("calendar_unknown");
+  const eventId = String(cand.ids.eventId || "");
+  if (!eventId || !mine.has(eventId)) return no("calendar_not_mine");
+  // An RSVP I made myself is my own echo, not news. (`own_echo` above only
+  // catches it when the RSVP was appended with me as the ACTOR; hq stamps the
+  // acting principal, which for a human-driven RSVP on my behalf is not me.)
+  if (cand.kind === "event.rsvp" && cand.hints && cand.hints.rsvpBy === me) {
+    return no("own_rsvp");
+  }
+  return yes("calendar", "attendee");
+}
+
 // ---------------------------------------------------------------------------
 // Per-family resolvers
 // ---------------------------------------------------------------------------
@@ -605,13 +666,70 @@ function resolveEscalation(cand, me, facts, on) {
   return no("not_my_escalation");
 }
 
-/** Approval: the approver seat is on the row, not in the payload — read it back. */
+/**
+ * Approval: the approver seat is on the row, not in the payload — read it back.
+ *
+ * ── WHY THIS IS NOT JUST `approver === me` ──
+ * It cannot be. hq's `methods/approval/request.ts` creates the row with
+ * `approver: NULL` — deliberately, because the G5 database CHECK constrains a
+ * SET approver and the approver is by definition the seat that LATER decides.
+ * So on a *pending* approval — the only kind anyone needs to act on — the
+ * `approver` column is always blank, and an "approver" verdict can only ever
+ * fire on an already-decided one, where the decider is someone else.
+ *
+ * The consequence, before this: `resolveApproval` had exactly one reachable
+ * branch, `requester === me` — the agent's own request echoing back. An approval
+ * raised BY a peer AGAINST a board item this seat reviews resolved as
+ * `not_my_approval` and was dropped at the transport. The live journey harness
+ * (`scripts/ci/journey-approval-escalation.mjs`) stopped there:
+ *
+ *     scanned=1 classified=1 directed=0 delivered=0
+ *     dropped={"not_my_approval":1}
+ *
+ * hq has no "requested of" column, so "is this on my desk?" has to be answered
+ * the way hq itself answers it when it decides where to post the approval CARD
+ * (`services/approval-artifact.ts`): by the approval's ATTACHMENTS. Two of them
+ * name a seat:
+ *
+ *   - the board item it BLOCKS. `approval.request` flips that Task to `blocked`,
+ *     so its assignee and reviewer are precisely the people whose work stopped.
+ *     That is the strongest claim in the system that an approval is yours, and
+ *     it is T0 — exactly as `resolveEscalation` already treats the same signal.
+ *   - the room its card is posted into (`subject.channelId`, or the blocked
+ *     task's channel). Membership of that room is T1: notice it, don't jump.
+ *
+ * ACL: every fact consulted here is the seat's OWN entitled read —
+ * `facts.taskRole` from `GET board.context`, `facts.memberChannelIds` from
+ * `messaging.channels`. Nothing is taken from the redacted org feed, and a room
+ * this seat is not in still never matches.
+ */
 function resolveApproval(cand, me, facts, on) {
   if (!on("approval")) return no("surface_disabled");
   const a = facts.approvals instanceof Map ? facts.approvals.get(String(cand.ids.approvalId)) : undefined;
   if (!a) return no(facts.approvals ? "approval_not_visible" : "approval_unknown");
   if (me && String(a.approver || "") === me) return yes("approval", "approver");
   if (me && String(a.requester || "") === me) return yes("approval", "requester");
+
+  // The blocked board item. `cand.ids.taskId` comes off the chain payload
+  // (`itemId`); `a.itemId` is the row's own copy — prefer the row, it cannot be
+  // stale relative to the frame.
+  const taskId = String(a.itemId || cand.ids.taskId || "");
+  const role = taskId && facts.taskRole instanceof Map ? facts.taskRole.get(taskId) : undefined;
+  if (role) return yes("approval", role); // "assignee" | "reviewer" — both T0
+
+  // The room the approval card lives in. Same explicit-only resolution hq uses:
+  // subject.channelId, else the blocked task's channel. Never a guessed room.
+  const subject = a.subject && typeof a.subject === "object" ? a.subject : {};
+  const task = taskId && facts.tasks instanceof Map ? facts.tasks.get(taskId) : null;
+  const channelId = String(subject.channelId || (task && task.channelId) || "");
+  if (channelId && has(asSet(facts.memberChannelIds), channelId)) {
+    return yes("approval", "channel");
+  }
+
+  // NEVER SILENT: an approval that named a task or a room we could not read is a
+  // different failure from one that genuinely is not ours, and the two must not
+  // share a reason string.
+  if (taskId && !(facts.taskRole instanceof Map)) return no("approval_board_unknown");
   return no("not_my_approval");
 }
 

package/lib/org/inbound/directedness.test.mjs

@@ -443,6 +443,73 @@ test("POSITIVE: the resolution of an approval I requested reaches me (payload-na
   assert.deepEqual({ s: v.surface, r: v.reason }, { s: "approval", r: "requester" });
 });
 
+/**
+ * THE BRANCH THAT MADE THIS SURFACE WORK AT ALL.
+ *
+ * hq creates an Approval with `approver: NULL` (G5 constrains only a SET
+ * approver, and the approver is the seat that LATER decides). So on a PENDING
+ * approval — the only kind anyone can act on — the `approver === me` branch
+ * above is unreachable, and `requester === me` only ever matches the agent's own
+ * request echoing back. Before this, an approval raised by a peer against a
+ * board item this seat REVIEWS resolved `not_my_approval` and was dropped at the
+ * transport. Live: `scanned=1 classified=1 directed=0 dropped={not_my_approval:1}`.
+ */
+test("POSITIVE: a PENDING approval blocking a task I review is mine, at T0", () => {
+  const f = facts({
+    approvals: new Map([["A-4", { id: "A-4", requester: THEM, approver: null, status: "pending", itemId: "T-9" }]]),
+    taskRole: new Map([["T-9", "reviewer"]]),
+    tasks: new Map([["T-9", { id: "T-9" }]]),
+  });
+  const c = classifyEvent(
+    ev({ family: "approval", kind: "approval.requested", entity_id: "A-4", payload: { requester: THEM, itemId: "T-9" } }),
+  );
+  const v = resolveDirected(c, ME, f);
+  assert.deepEqual({ s: v.surface, r: v.reason }, { s: "approval", r: "reviewer" });
+});
+
+test("POSITIVE: assignee of the blocked item counts too — their work is what stopped", () => {
+  const f = facts({
+    approvals: new Map([["A-5", { id: "A-5", requester: THEM, approver: null, status: "pending", itemId: "T-1" }]]),
+    taskRole: new Map([["T-1", "assignee"]]),
+  });
+  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-5", payload: { requester: THEM, itemId: "T-1" } }));
+  assert.equal(resolveDirected(c, ME, f).reason, "assignee");
+});
+
+test("POSITIVE: membership of the room the approval CARD lives in is T1, not T0", () => {
+  // Mirrors hq services/approval-artifact.ts: subject.channelId, else the
+  // blocked task's channel. Noticing it is not the same as owning it.
+  const f = facts({
+    approvals: new Map([["A-6", { id: "A-6", requester: THEM, approver: null, status: "pending", subject: { channelId: "C-priv" } }]]),
+    taskRole: new Map(),
+  });
+  withChannel(f, "C-priv", "PRIVATE");
+  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-6", payload: { requester: THEM } }));
+  assert.equal(resolveDirected(c, ME, f).reason, "channel");
+});
+
+test("NEGATIVE: a room I am NOT in never makes an approval mine", () => {
+  const f = facts({
+    approvals: new Map([["A-7", { id: "A-7", requester: THEM, approver: null, status: "pending", subject: { channelId: "C-theirs" } }]]),
+    taskRole: new Map(),
+  });
+  // visible (PUBLIC) is not membership, and never gets upgraded to it
+  withChannel(f, "C-theirs", "PUBLIC");
+  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-7", payload: { requester: THEM } }));
+  assert.equal(resolveDirected(c, ME, f).directed, false);
+});
+
+test("an unreadable board is reported as such, not collapsed into `not mine`", () => {
+  const f = facts({
+    approvals: new Map([["A-8", { id: "A-8", requester: THEM, approver: null, status: "pending", itemId: "T-?" }]]),
+    taskRole: null, // board.context failed this tick
+  });
+  const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-8", payload: { requester: THEM, itemId: "T-?" } }));
+  const v = resolveDirected(c, ME, f);
+  assert.equal(v.directed, false);
+  assert.equal(v.reason, "approval_board_unknown", "a failed read must not look like a negative verdict");
+});
+
 test("NEGATIVE: an approval on someone else's desk is not directed", () => {
   const f = facts({ approvals: new Map([["A-3", { id: "A-3", requester: THEM, approver: "M-boss", status: "pending" }]]) });
   const c = classifyEvent(ev({ family: "approval", kind: "approval.requested", entity_id: "A-3", payload: { requester: THEM } }));

package/lib/org/inbound/facts.mjs

@@ -17,6 +17,7 @@
  *   | open escalations           | escalation.list         | org-scoped                      |
  *   | approvals (approver seat)  | approval.get            | org-scoped, NOT_FOUND otherwise |
  *   | doc ownership / shares     | files.get               | NOT_FOUND when not visible      |
+ *   | my calendar events         | calendar.list           | owner OR attendee, lens floor   |
  *
  * ── THE ONE RULE THIS FILE ENFORCES ──
  * A channel that is not in the visible roster is NEVER paged. `messaging.channels`
@@ -76,6 +77,8 @@ export const DEFAULT_LIMITS = Object.freeze({
  * @property {Map<string,object>|null} escalations
  * @property {Map<string,object>|null} approvals
  * @property {Map<string,object>|null} fileAcl     fileId → {ownerId, shared, mentionsMe}
+ * @property {Set<string>|null} myEventIds        calendar events I own or attend (null == unreadable)
+ * @property {Map<string,object>|null} myEvents   eventId → the calendar event DTO
  * @property {string[]} degraded               names of facts that could not be read
  */
 
@@ -126,6 +129,8 @@ export async function resolveFacts(o = {}) {
     escalations: null,
     approvals: null,
     fileAcl: null,
+    myEventIds: null,
+    myEvents: null,
     degraded,
   };
   if (!io || candidates.length === 0) return facts;
@@ -148,8 +153,29 @@ export async function resolveFacts(o = {}) {
         // `messaging.channels` returns a NON-PUBLIC channel only to its members,
         // so appearing here with a non-PUBLIC kind IS the membership proof. For
         // a PUBLIC channel the roster proves visibility, never membership — and
-        // we never upgrade one to the other.
-        if (kind && kind !== "PUBLIC") members.add(id);
+        // we never upgrade one to the other by GUESSING.
+        //
+        // hq now states it outright: `joined` is the acting member's OWN
+        // membership row (hq src/server/methods/messaging/channels.ts), pinned
+        // to the requester, so it discloses nothing about anyone else. Without
+        // it every huddle started in a PUBLIC space was dropped `not_a_member`
+        // — verified live on `calling/start` seq 8194 in a space the agent
+        // really is a member of. `joined` is TRUSTED ONLY WHEN TRUE and only on
+        // a PUBLIC row: an older hq omits the field, `joined` is undefined, and
+        // the old visibility-only behaviour stands. A private room is still
+        // proven by its kind alone, so a `joined:false` from any hq can never
+        // close a room membership already proved.
+        const joined = c && c.joined === true;
+        if ((kind && kind !== "PUBLIC") || joined) members.add(id);
+      }
+      if (rows.length > 0 && !rows.some((c) => c && typeof c.joined === "boolean")) {
+        // FAIL-OPEN IS FINE; SILENT IS NOT. On an hq that predates `joined`,
+        // public-space membership is unknowable and every huddle/file event in
+        // a public space will be dropped. Say which capability is dark.
+        log(
+          "warn",
+          "[inbound] messaging.channels carries no `joined` flag (older hq) — membership of PUBLIC spaces is unknowable, so calls and file comments in public spaces WILL be dropped as not_a_member",
+        );
       }
       facts.visibleChannelIds = visible;
       facts.memberChannelIds = members;
@@ -166,7 +192,24 @@ export async function resolveFacts(o = {}) {
   }
 
   // ── 3. Board: my tasks (assignee OR reviewer) from the board context read.
-  if (families.has("board") || families.has("escalation") || families.has("file")) {
+  //
+  // `approval` is in this list for the same reason `escalation` is: an approval
+  // BLOCKS a board item (`approval.request` flips the Task to `blocked`), and
+  // the assignee/reviewer of the item whose work just stopped is the closest
+  // thing hq has to "the seat this approval is asked of" — hq's Approval row
+  // carries no such column, so `resolveApproval` has to reach the board to
+  // answer at all. Without this line `facts.taskRole` is null on an
+  // approval-only tick, every approval reads as `not_my_approval`, and the
+  // surface is dark no matter what the resolver says.
+  //
+  // It is ONE `GET board.context` shared across every family in the tick, so
+  // widening it here costs nothing when board events are already present.
+  if (
+    families.has("board") ||
+    families.has("escalation") ||
+    families.has("file") ||
+    families.has("approval")
+  ) {
     await resolveBoardFacts({ facts, io, log, degraded });
   }
 
@@ -203,9 +246,63 @@ export async function resolveFacts(o = {}) {
     await resolveFileFacts({ candidates, facts, io, limits, log, degraded });
   }
 
+  // ── 8. Calendar: which events are MINE. `calendar.list` with no
+  //      `calendarMemberId` is the acting seat's own viewpoint — hq returns
+  //      events where the seat owns the calendar OR appears in `attendeeRows`,
+  //      under the PERSONAL_RESTRICTED lens floor. One read per pull.
+  if (families.has("calendar") && (on("calendar") || !enabled)) {
+    await resolveCalendarFacts({ candidates, facts, io, log, degraded });
+  }
+
   return facts;
 }
 
+/**
+ * My calendar. ONE `calendar.list` per pull, windowed around the events this
+ * batch actually mentions so a long-lived agent does not re-page its whole year.
+ *
+ * A failed read leaves `myEventIds === null`, which `resolveCalendar` treats as
+ * "unknown" and therefore NOT directed — a calendar is a private surface and the
+ * safe direction is closed. It is logged, never silent.
+ */
+async function resolveCalendarFacts({ candidates, facts, io, log, degraded }) {
+  // Window: [earliest mentioned start - 1d, latest + 1d], falling back to a
+  // ±30d window around now when no payload carried a usable timestamp.
+  const stamps = [];
+  for (const c of candidates) {
+    if (!c || c.family !== "calendar") continue;
+    for (const v of [c.ids && c.ids.startsAt, c.at]) {
+      const t = v ? Date.parse(v) : NaN;
+      if (Number.isFinite(t)) stamps.push(t);
+    }
+  }
+  const DAY = 86_400_000;
+  const now = Date.now();
+  const lo = (stamps.length ? Math.min(...stamps) : now - 30 * DAY) - DAY;
+  const hi = (stamps.length ? Math.max(...stamps) : now + 30 * DAY) + DAY;
+
+  const frame = await io.call("calendar.list", {
+    fromIso: new Date(lo).toISOString(),
+    toIso: new Date(hi).toISOString(),
+    limit: 200,
+  });
+  if (!frame || frame.ok !== true) {
+    degraded.push("calendar");
+    log("warn", "[inbound] calendar.list unreadable — calendar events stay CLOSED this tick (a private surface fails closed)");
+    return;
+  }
+  const ids = new Set();
+  const byId = new Map();
+  for (const e of arrayOf(resultOf(frame), "events")) {
+    const id = String((e && e.id) || "");
+    if (!id) continue;
+    ids.add(id);
+    byId.set(id, e);
+  }
+  facts.myEventIds = ids;
+  facts.myEvents = byId;
+}
+
 // ---------------------------------------------------------------------------
 // Step implementations
 // ---------------------------------------------------------------------------
@@ -343,7 +440,18 @@ async function resolveBoardFacts({ facts, io, log, degraded }) {
   }
   const role = new Map();
   const tasks = new Map();
-  for (const task of collectTasks(r.payload)) {
+  const collected = collectTasks(r.payload);
+  // NEVER SILENT. `board.context` answering 200 with a payload we then extract
+  // ZERO tasks from is not "an empty board" — it is almost always a shape
+  // mismatch, and it degrades every board verdict to `not_my_task` while every
+  // log line stays green. That is exactly how it failed: hq nests cards at
+  // board.swimlanes[].columns[].tasks[] (depth 7) and this walker stopped at 6,
+  // so 144 live tasks — 3 of them assigned to the seat — extracted as 0.
+  if (collected.length === 0 && r.payload && Object.keys(r.payload).length > 0) {
+    log("warn", "[inbound] board.context returned a payload but NO task cards were recognised — every board event will read as not_my_task this tick. This is a shape mismatch, not an empty board.");
+    degraded.push("board_shape");
+  }
+  for (const task of collected) {
     const id = String((task && task.id) || "");
     if (!id) continue;
     tasks.set(id, task);
@@ -357,16 +465,31 @@ async function resolveBoardFacts({ facts, io, log, degraded }) {
 }
 
 /**
- * `board.context` is a swimlane projection (`{lanes:[{columns:{col:[card]}}]}`),
- * and older/alternate shapes exist. Walk defensively and collect anything that
- * looks like a task card — a shape change upstream must degrade to "fewer
- * tasks", never to a throw.
+ * `board.context` is a swimlane projection and older/alternate shapes exist.
+ * Walk defensively and collect anything that looks like a task card — a shape
+ * change upstream must degrade to "fewer tasks", never to a throw.
+ *
+ * THE DEPTH CAP IS LOAD-BEARING AND WAS OFF BY ONE. hq's live shape is
+ *
+ *   payload → board → swimlanes[] → swimlane → columns[] → column → tasks[] → task
+ *      0        1          2            3          4          5        6        7
+ *
+ * i.e. the cards sit at depth SEVEN. The cap was `depth > 6`, so `visit` was
+ * called on every task and returned immediately, and this function reported an
+ * empty board against a live org holding 144 tasks (3 assigned to the seat).
+ * Nothing threw and nothing logged: `facts.taskRole` was an empty Map, which
+ * `resolveBoard` reads as "none of these are mine", so EVERY board event was
+ * dropped as `not_my_task` — the wide reader was wired correctly and still
+ * delivered no task, ever.
+ *
+ * 12 is chosen with headroom for a projection that adds a wrapper or two, and
+ * the caller now LOGS a zero-card extraction rather than trusting it.
  */
 export function collectTasks(payload) {
   const out = [];
   const seen = new Set();
   const visit = (node, depth) => {
-    if (!node || depth > 6) return;
+    if (!node || depth > 12) return;
     if (Array.isArray(node)) {
       for (const n of node) visit(n, depth + 1);
       return;

package/lib/org/inbound/facts.test.mjs

@@ -129,6 +129,44 @@ test("a PUBLIC channel is visible but NOT proof of membership", async () => {
   assert.deepEqual([...facts.memberChannelIds].sort(), ["C-dm", "C-priv"]);
 });
 
+test("an older hq with no `joined` flag says out loud that public membership is dark", async () => {
+  const io = fakeIo({ ...ROSTER, "messaging.history": () => okFrame({ messages: [] }) });
+  await resolveFacts({ candidates: [msgEvent("C-pub", "PUBLIC", "m1")], me: ME, io });
+  assert.ok(
+    io.logs.some((l) => /no `joined` flag/.test(l.message)),
+    "a dark capability must be named, not inferred from an agent that never answers",
+  );
+});
+
+test("`joined:true` on a PUBLIC room IS membership — the huddle-in-a-public-space fix", async () => {
+  const roster = {
+    "messaging.channels": okFrame({
+      channels: [
+        { id: "C-dm", kind: "DM", slug: "dm-them", name: "them", joined: true },
+        { id: "C-pub", kind: "PUBLIC", slug: "platform", name: "Platform", joined: true },
+        { id: "C-seen", kind: "PUBLIC", slug: "risk", name: "Risk", joined: false },
+      ],
+    }),
+  };
+  const io = fakeIo({ ...roster, "messaging.history": () => okFrame({ messages: [] }) });
+  const facts = await resolveFacts({ candidates: [msgEvent("C-pub", "PUBLIC", "m1")], me: ME, io });
+
+  // Seen-but-not-joined stays out. That is the whole safety property.
+  assert.deepEqual([...facts.memberChannelIds].sort(), ["C-dm", "C-pub"]);
+  assert.deepEqual([...facts.visibleChannelIds].sort(), ["C-dm", "C-pub", "C-seen"]);
+});
+
+test("`joined:false` can never close a private room membership the kind already proved", async () => {
+  const roster = {
+    "messaging.channels": okFrame({
+      channels: [{ id: "C-priv", kind: "PRIVATE", slug: "leads", name: "Leads", joined: false }],
+    }),
+  };
+  const io = fakeIo({ ...roster, "messaging.history": () => okFrame({ messages: [] }) });
+  const facts = await resolveFacts({ candidates: [msgEvent("C-priv", "PRIVATE", "m1")], me: ME, io });
+  assert.deepEqual([...facts.memberChannelIds], ["C-priv"]);
+});
+
 // ---------------------------------------------------------------------------
 // cost: the redacted counts avoid pages entirely
 // ---------------------------------------------------------------------------
@@ -373,3 +411,61 @@ test("a disabled surface is never probed for", async () => {
   });
   assert.equal(io.calls.filter((c) => c.method === "messaging.history").length, 0);
 });
+
+// ---------------------------------------------------------------------------
+// collectTasks depth (JOINT 3) — the live shape, not a convenient one
+// ---------------------------------------------------------------------------
+
+/**
+ * Regression, found against the LIVE org: hq's `GET board.context` nests cards
+ * at `board.swimlanes[].columns[].tasks[]`, which is depth SEVEN from the
+ * payload root. The walker capped at `depth > 6`, so it extracted 0 cards from
+ * a board holding 144 — 3 of them assigned to the seat — and every board event
+ * was then dropped as `not_my_task`. Silently: nothing threw, nothing logged.
+ */
+test("collectTasks reaches hq's REAL board.context depth (board>swimlanes>columns>tasks)", () => {
+  const live = {
+    board: {
+      columns: ["triage", "todo", "done"],
+      swimlanes: [
+        {
+          workstreamId: "ws-1",
+          name: "Alpha Research",
+          status: "active",
+          objective: null,
+          ownerId: "M-boss",
+          columns: [
+            { col: "todo", tasks: [{ id: "T-1", title: "Ship it", col: "todo", assigneeId: "M-me", reviewerId: null }] },
+            { col: "done", tasks: [{ id: "T-2", title: "Old", col: "done", assigneeId: "M-them", reviewerId: "M-me" }] },
+          ],
+          taskCount: 2,
+        },
+      ],
+    },
+  };
+  const tasks = collectTasks(live);
+  assert.equal(tasks.length, 2, "a task at depth 7 must be reachable — this is hq's actual wire shape");
+  assert.deepEqual(tasks.map((t) => t.id).sort(), ["T-1", "T-2"]);
+});
+
+test("board.context that yields NO task cards is reported as a shape mismatch, not an empty board", async () => {
+  const logs = [];
+  const io = {
+    stats: { calls: 0, reads: 0, failures: 0, methods: [] },
+    log: (level, message) => logs.push({ level, message }),
+    async call() { return { ok: false, error: { code: "NOT_FOUND", message: "x" } }; },
+    // 200 with a payload the walker recognises nothing in.
+    async read() { return { ok: true, status: 200, payload: { board: { somethingElse: [{ nope: 1 }] } } }; },
+  };
+  const facts = await resolveFacts({
+    candidates: [{ seq: 1, family: "board", kind: "item.assigned", entityId: "T-9", actor: "M-boss", at: "", topic: "task", surfaces: ["task_assigned"], ids: { taskId: "T-9" }, directTo: [], payload: {} }],
+    me: "M-me",
+    io,
+  });
+  assert.equal(facts.taskRole.size, 0);
+  assert.ok(facts.degraded.includes("board_shape"), "the degradation is reported so a green log is not mistaken for a quiet board");
+  assert.ok(
+    logs.some((l) => l.level === "warn" && /shape mismatch, not an empty board/.test(l.message)),
+    `fail-open is fine, silent is not; got ${JSON.stringify(logs)}`,
+  );
+});