@cohortapp/agent-sdk 2.11.15 → 2.13.0

package/lib/org/board-mine-cache.mjs

@@ -0,0 +1,99 @@
+/**
+ * lib/org/board-mine-cache.mjs — the pure half of the daemon's board-mine
+ * cache (design 2026-09-08 §3.5; left over from WP-M2/M4).
+ *
+ * The daemon asks hq `board.mine` (`lib/org/client.mjs#listMine`, fail-open
+ * `[]`) every five minutes and writes the answer to
+ * `state/org/board-mine.json` as `{ts, items:[...]}`. Three readers already
+ * exist: the SessionStart primer (`lib/session/status-summary.mjs`), the
+ * `session_status` MCP tool and `maestro board mine` (`lib/cli/board.mjs`,
+ * which falls back to this cache when the live read is empty). This module
+ * decides WHEN to refresh and WHAT to write; the daemon does the I/O.
+ *
+ * @module lib/org/board-mine-cache
+ */
+
+"use strict";
+
+/** Five minutes, per the design. */
+export const REFRESH_INTERVAL_MS = 5 * 60_000;
+
+/** Where the daemon writes the cache, relative to the agent root. */
+export const BOARD_MINE_REL = "state/org/board-mine.json";
+
+/**
+ * Should the cache be refreshed now? Pure. `lastTs` is the `ts` of the last
+ * write (ISO string or epoch ms; null/invalid = never), `now` is epoch ms.
+ * A clock that went backwards (lastTs in the future) also refreshes, so a
+ * bad timestamp can never freeze the cache.
+ * @param {string|number|null|undefined} lastTs
+ * @param {number} now
+ * @param {number} [intervalMs]
+ * @returns {boolean}
+ */
+export function shouldRefresh(lastTs, now, intervalMs = REFRESH_INTERVAL_MS) {
+  const last = toMs(lastTs);
+  if (last === null) return true;
+  if (last > now) return true;
+  return now - last >= intervalMs;
+}
+
+/**
+ * The document to write. Pure. Non-array or non-object items are dropped so a
+ * malformed server answer cannot poison the readers.
+ * @param {unknown} items   what listMine() returned
+ * @param {number} now      epoch ms
+ * @returns {{ts:string, items:object[]}}
+ */
+export function render(items, now) {
+  const list = Array.isArray(items) ? items.filter((it) => it && typeof it === "object" && !Array.isArray(it)) : [];
+  return { ts: new Date(now).toISOString(), items: list };
+}
+
+/**
+ * What to write after a refresh attempt. Pure. A successful read renders the
+ * fresh items; a FAILED read keeps the previous document's items (last known
+ * good) and marks the document `stale: true` with `itemsAt` = when those
+ * items were actually fetched — so one unreachable hq tick does not turn the
+ * SessionStart primer, session_status and `maestro board mine` into "zero
+ * items" for five minutes. With nothing previous, a failed read renders
+ * empty-and-stale.
+ * @param {{ok:boolean, items?:unknown, error?:string}|unknown[]|null|undefined} result  listMineResult() (an array is treated as ok)
+ * @param {unknown} prev   the current cache document (or null)
+ * @param {number} now     epoch ms
+ * @returns {{ts:string, items:object[], stale?:true, itemsAt?:string|null, error?:string}}
+ */
+export function renderRefresh(result, prev, now) {
+  const r = Array.isArray(result) ? { ok: true, items: result } : (result && typeof result === "object" ? result : { ok: false, items: [] });
+  if (r.ok) return render(r.items, now);
+  const prevDoc = prev && typeof prev === "object" && !Array.isArray(prev) ? prev : null;
+  const kept = render(prevDoc ? prevDoc.items : [], now);
+  const itemsAt = prevDoc ? (prevDoc.stale && prevDoc.itemsAt !== undefined ? prevDoc.itemsAt : cacheTs(prevDoc)) : null;
+  const doc = { ...kept, stale: true, itemsAt: itemsAt || null };
+  if (r.error) doc.error = String(r.error).slice(0, 200);
+  return doc;
+}
+
+/**
+ * The `ts` of an existing cache document, or null. Tolerates the pre-M6
+ * `{fetchedAt}` spelling and a bare array (no timestamp → refresh).
+ * @param {unknown} doc
+ * @returns {string|null}
+ */
+export function cacheTs(doc) {
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) return null;
+  if (typeof doc.ts === "string") return doc.ts;
+  if (typeof doc.fetchedAt === "string") return doc.fetchedAt;
+  return null;
+}
+
+function toMs(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Date.parse(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return null;
+}
+
+export default { shouldRefresh, render, renderRefresh, cacheTs, REFRESH_INTERVAL_MS, BOARD_MINE_REL };

package/lib/org/board-mine-cache.test.mjs

@@ -0,0 +1,53 @@
+/**
+ * board-mine-cache.test.mjs — the pure half of the daemon's 5-minute
+ * state/org/board-mine.json cache.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { shouldRefresh, render, renderRefresh, cacheTs, REFRESH_INTERVAL_MS, BOARD_MINE_REL } from "./board-mine-cache.mjs";
+
+const NOW = Date.parse("2026-09-08T12:00:00Z");
+
+test("shouldRefresh: never written → yes; younger than 5 min → no; 5 min or older → yes; a future ts → yes", () => {
+  assert.equal(shouldRefresh(null, NOW), true);
+  assert.equal(shouldRefresh(undefined, NOW), true);
+  assert.equal(shouldRefresh("garbage", NOW), true);
+  assert.equal(shouldRefresh("2026-09-08T11:56:00Z", NOW), false);
+  assert.equal(shouldRefresh(NOW - REFRESH_INTERVAL_MS + 1, NOW), false);
+  assert.equal(shouldRefresh("2026-09-08T11:55:00Z", NOW), true);
+  assert.equal(shouldRefresh(NOW - REFRESH_INTERVAL_MS, NOW), true);
+  assert.equal(shouldRefresh("2026-09-08T12:30:00Z", NOW), true, "a clock that went backwards must not freeze the cache");
+  assert.equal(shouldRefresh("2026-09-08T11:59:30Z", NOW, 10_000), true, "interval is a parameter");
+  assert.equal(REFRESH_INTERVAL_MS, 300_000);
+  assert.equal(BOARD_MINE_REL, "state/org/board-mine.json");
+});
+
+test("render: {ts, items} with only object items kept; a non-array answer renders as empty", () => {
+  const doc = render([{ itemId: "i1", title: "Do X" }, null, "junk", [1], { itemId: "i2" }], NOW);
+  assert.deepEqual(doc, { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i1", title: "Do X" }, { itemId: "i2" }] });
+  assert.deepEqual(render(undefined, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [] });
+  assert.deepEqual(render({ items: [{ itemId: "x" }] }, NOW).items, [], "an object is not the items array (listMine already unwraps)");
+});
+
+test("cacheTs reads ts, tolerates the earlier fetchedAt spelling, and is null for a bare array or junk", () => {
+  assert.equal(cacheTs({ ts: "2026-09-08T11:59:00Z", items: [] }), "2026-09-08T11:59:00Z");
+  assert.equal(cacheTs({ fetchedAt: "2026-09-08T11:59:00Z", items: [] }), "2026-09-08T11:59:00Z");
+  assert.equal(cacheTs([{ itemId: "x" }]), null);
+  assert.equal(cacheTs(null), null);
+  assert.equal(cacheTs({ items: [] }), null);
+});
+
+test("renderRefresh: a successful read renders fresh items; a FAILED read keeps the previous items, marks stale and remembers when they were fetched", () => {
+  const prev = { ts: "2026-09-08T11:55:00.000Z", items: [{ itemId: "i1" }] };
+  assert.deepEqual(renderRefresh({ ok: true, items: [{ itemId: "i2" }] }, prev, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i2" }] });
+  assert.deepEqual(renderRefresh([{ itemId: "i3" }], prev, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i3" }] }, "a bare array (the old listMine shape) is a success");
+  assert.deepEqual(renderRefresh({ ok: true, items: [] }, prev, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [] }, "an empty board is a real answer, not a failure");
+  const failed = renderRefresh({ ok: false, items: [], error: "http 503" }, prev, NOW);
+  assert.deepEqual(failed, { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i1" }], stale: true, itemsAt: "2026-09-08T11:55:00.000Z", error: "http 503" });
+  const failedAgain = renderRefresh({ ok: false, items: [] }, failed, NOW + 300_000);
+  assert.equal(failedAgain.itemsAt, "2026-09-08T11:55:00.000Z", "a second failure keeps the ORIGINAL fetch time, not the last stale write");
+  assert.deepEqual(failedAgain.items, [{ itemId: "i1" }]);
+  assert.deepEqual(renderRefresh({ ok: false, items: [] }, null, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [], stale: true, itemsAt: null }, "nothing previous → empty and stale");
+  assert.deepEqual(renderRefresh(null, prev, NOW).items, [{ itemId: "i1" }], "a null result is a failure");
+});

package/lib/org/board.mjs

@@ -128,6 +128,17 @@ export function ready(opts = {}) {
   return resolveClient(opts).listReady(rpcOpts(opts));
 }
 
+/**
+ * Read THIS agent's items across every board (GET /v1/board.mine — assignee
+ * or reviewer = caller). Returns the items array, or [] on any failure
+ * (fail-open; an hq without the read yet answers 404 → []).
+ * @param {object} [opts] - { client?, base, token, fetchImpl? }
+ * @returns {Promise<object[]>}
+ */
+export function mine(opts = {}) {
+  return resolveClient(opts).listMine(rpcOpts(opts));
+}
+
 // ---------------------------------------------------------------------------
 // Read-only YAML projection writer
 // ---------------------------------------------------------------------------

package/lib/org/board.test.mjs

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import {
-  createItem, claimItem, completeItem, decompose, assign, link, ready,
+  createItem, claimItem, completeItem, decompose, assign, link, ready, mine,
   buildProjection, writeProjection, writeReadyProjection,
 } from "./board.mjs";
 import { okFrame, errFrame, BOARD_STATUS } from "./protocol.mjs";
@@ -38,6 +38,7 @@ function fakeClient(map = {}) {
     boardAssign: make("boardAssign"),
     boardLink: make("boardLink"),
     listReady: make("listReady"),
+    listMine: make("listMine"),
   };
 }
 
@@ -175,3 +176,12 @@ test("writeReadyProjection: down server (empty ready) writes an empty projection
     assert.equal(doc.count, 0);
   } finally { rmSync(root, { recursive: true, force: true }); }
 });
+
+test("mine: routes to client.listMine, forwarding conn opts (fail-open [] handled by the client)", async () => {
+  const client = fakeClient({ listMine: () => [{ itemId: "m1" }] });
+  assert.deepEqual(await mine({ client, ...CONN }), [{ itemId: "m1" }]);
+  // listMine takes ONE argument (the conn opts), like listReady.
+  const c = client.calls.find((x) => x.name === "listMine");
+  assert.equal(c.params.base, CONN.base);
+  assert.equal(c.params.token, CONN.token);
+});

package/lib/org/client.mjs

@@ -694,6 +694,42 @@ export async function listReady(o = {}) {
   return [];
 }
 
+/**
+ * List every board item assigned to (or under review by) THIS agent across all
+ * boards and workstreams (GET /v1/board.mine — hq 2026-09, front-door session
+ * §3.5). Returns the items array, or [] on any failure (fail-open): an older hq
+ * without the read answers 404 and this returns [], same as listReady.
+ * Item shape: {itemId, title, boardId, boardName, channelId, workstreamId, col,
+ * stage, priority, dueAt, updatedAt, url}.
+ * @param {object} o - { base, token, orgId?, fetchImpl? }
+ * @returns {Promise<object[]>}
+ */
+export async function listMine(o = {}) {
+  return (await listMineResult(o)).items;
+}
+
+/**
+ * `listMine` with the failure kept visible: `{ok:false, items:[]}` when hq
+ * could not be read, `{ok:true, items}` otherwise (an empty board is
+ * `ok:true`). The daemon's board-mine cache needs the difference so one
+ * unreachable tick does not overwrite the last known good answer with [].
+ * Never throws.
+ * @param {object} o - { base, token, orgId, fetchImpl? }
+ * @returns {Promise<{ok:boolean, items:object[], error?:string}>}
+ */
+export async function listMineResult(o = {}) {
+  try {
+    const r = await read("board.mine", o);
+    if (!r.ok) return { ok: false, items: [], error: (r.error && r.error.message) || `http ${r.status || 0}` };
+    if (!r.payload) return { ok: true, items: [] };
+    if (Array.isArray(r.payload)) return { ok: true, items: r.payload };
+    if (Array.isArray(r.payload.items)) return { ok: true, items: r.payload.items };
+    return { ok: true, items: [] };
+  } catch (err) {
+    return { ok: false, items: [], error: String((err && err.message) || err) }; // read() never throws; belt-and-braces for a throwing fetchImpl
+  }
+}
+
 /**
  * Fetch the event slice (GET /v1/events?cursor=N&limit=500). Returns the events
  * array (or [] on failure). The caller pipes these to verify.verifyEvents.

package/lib/org/client.test.mjs

@@ -35,6 +35,9 @@ import {
   claimItem,
   completeItem,
   listReady,
+  listMine,
+  listMineResult,
+  trackWork,
   fetchEvents,
   fetchSnapshot,
   publishEntry,
@@ -1158,3 +1161,46 @@ test("loadOrgConfig: a PRESENT but unparseable org.yaml WARNS (never silently un
   assert.match(warnings.join("\n"), /could not be loaded/, "the operator must be told");
   assert.match(warnings.join("\n"), /NOT enrolled/, "and told what it means");
 });
+
+// ── WP-M4: board.mine + board.track passthrough (front-door session §3.5) ──
+
+test("listMineResult: keeps the failure visible — {ok:false} on an error frame or a throwing transport, {ok:true, items:[]} for an empty board", async () => {
+  assert.deepEqual(await listMineResult({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: [{ itemId: "i1" }] })) }), { ok: true, items: [{ itemId: "i1" }] });
+  assert.deepEqual(await listMineResult({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: { items: [] } })) }), { ok: true, items: [] }, "an empty board is a real answer");
+  const failed = await listMineResult({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 503, body: { error: { code: "UNAVAILABLE", message: "hq down" } } })) });
+  assert.equal(failed.ok, false);
+  assert.deepEqual(failed.items, []);
+  assert.match(failed.error, /hq down/);
+  const threw = await listMineResult({ base: BASE, token: TOKEN, fetchImpl: () => { throw new Error("ECONNREFUSED"); } });
+  assert.equal(threw.ok, false);
+  assert.deepEqual(threw.items, []);
+  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: () => { throw new Error("ECONNREFUSED"); } }), [], "listMine stays the fail-open [] its other callers expect");
+});
+
+test("listMine: GET /v1/board.mine; parses array and {items:[]}; [] on error / transport failure (fail-open)", async () => {
+  const f = fakeFetch(() => ({ body: [{ itemId: "i1", title: "Deck" }] }));
+  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: f }), [{ itemId: "i1", title: "Deck" }]);
+  assert.match(f.calls[0].url, /\/v1\/board\.mine$/);
+  assert.equal(f.calls[0].init.method, "GET");
+  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ body: { items: [{ itemId: "i2" }] } })) }), [{ itemId: "i2" }]);
+  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: fakeFetch(() => ({ ok: false, status: 404, body: { error: { code: "NOT_FOUND" } } })) }), [], "an hq without board.mine yet → []");
+  assert.deepEqual(await listMine({ base: BASE, token: TOKEN, fetchImpl: async () => { throw new Error("boom"); } }), []);
+  assert.deepEqual(await listMine({ base: "", token: TOKEN }), [], "no base → []");
+});
+
+test("trackWork: title/why/stage (incl. accepted|done) pass through to board.track verbatim", async () => {
+  const f = fakeFetch(() => ({ body: { ok: true, result: { tracked: true, taskId: "t1" } } }));
+  const r = await trackWork(
+    { service: "cohort", channelId: "c1", messageId: "m1", stage: "accepted", title: "Build the deck", why: "asked in DM" },
+    { base: BASE, token: TOKEN, fetchImpl: f, idempotencyKey: "k1" },
+  );
+  assert.equal(r.ok, true);
+  const body = JSON.parse(f.calls[0].init.body);
+  assert.equal(body.stage, "accepted");
+  assert.equal(body.title, "Build the deck");
+  assert.equal(body.why, "asked in DM");
+  assert.equal(body.channelId, "c1");
+  const f2 = fakeFetch(() => ({ body: { ok: true, result: { tracked: true } } }));
+  await trackWork({ service: "cohort", channelId: "c1", messageId: "m1", stage: "done" }, { base: BASE, token: TOKEN, fetchImpl: f2 });
+  assert.equal(JSON.parse(f2.calls[0].init.body).stage, "done");
+});

package/lib/org/inbound/directedness.mjs

@@ -406,7 +406,9 @@ function yes(surface, reason, extra = {}) {
  * @param {Candidate} cand
  * @param {string} me the agent's member id
  * @param {import("./facts.mjs").Facts} facts
- * @param {{enabled?: Record<string,boolean>}} [opts]
+ * @param {{enabled?: Record<string,boolean>, meAliases?: string[]}} [opts]
+ *   `meAliases` — additional identity strings for this seat (slug, member id,
+ *   agent email). Used ONLY to widen own-echo suppression; never to widen reach.
  * @returns {{directed:boolean, surface:string|null, reason:string, why:string}}
  */
 export function resolveDirected(cand, me, facts = {}, opts = {}) {
@@ -414,10 +416,24 @@ export function resolveDirected(cand, me, facts = {}, opts = {}) {
   const enabled = opts.enabled || null;
   const on = (s) => (enabled ? !!enabled[s] : true);
   const meId = me ? String(me) : "";
+  // Every identity string that means "this seat". `me` SHOULD be the org member
+  // id (a cuid), because that is what hq stamps on `actor` and `directTo`. But a
+  // real machine can just as easily hand us the SLUG ("A028") — COHORT_AGENT_ID
+  // holds a slug, and the daemon's responder-election path needs it that way.
+  // When the slug arrives here, `actor === meId` compares across two namespaces,
+  // never matches, and the own-echo drop below silently stops existing. Echo
+  // suppression must not depend on which alias the caller happened to pass, so
+  // match ANY known alias. Observed in production 2026-08-26: A028 re-ingested
+  // its own morning brief and its own holding note and began answering itself.
+  const meAliases = new Set(
+    [meId, ...(Array.isArray(opts.meAliases) ? opts.meAliases : [])]
+      .map((v) => (v == null ? "" : String(v).trim()))
+      .filter(Boolean),
+  );
 
   // My OWN echo is never inbound. This is the single most important drop: without
   // it an agent re-ingests its own replies and holds a conversation with itself.
-  if (meId && cand.actor && cand.actor === meId) return no("own_echo");
+  if (cand.actor && meAliases.has(String(cand.actor))) return no("own_echo");
 
   // A payload that named me outright needs no join at all.
   if (meId && cand.directTo.map(String).includes(meId)) {

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

@@ -145,6 +145,64 @@ test("NEGATIVE: my own echo is never inbound", () => {
   assert.equal(resolveDirected(c, ME, f).reason, "own_echo");
 });
 
+// --- own-echo across id namespaces (regression, production 2026-08-26) -------
+//
+// `me` SHOULD be the org member cuid — that is what hq stamps on `actor`. But
+// COHORT_AGENT_ID holds a SLUG and the daemon's responder-election path needs it
+// that way, so a slug reaches this resolver on a real machine. Strict equality
+// on one id then compares across two namespaces: it does not throw, it answers
+// "no" to every identity question, and the own-echo drop silently stops
+// existing. That is how a seat re-ingested its own morning brief and its own
+// holding note and began answering itself.
+//
+// These tests exist because nothing turns red when this lapses. The failure has
+// no runtime signal at all — only an assertion.
+
+const ME_SLUG = "A028";
+
+test("REGRESSION: a SLUG in the me position still suppresses my own echo", () => {
+  const f = withChannel(facts(), "C-dm", "DM");
+  const c = classifyEvent(
+    ev({ family: "messaging", kind: "send", actor: ME, entity_id: "m1", payload: { actor: ME, channelId: "C-dm", channelKind: "DM" } }),
+  );
+  // hq stamped the cuid; the caller handed us the slug. Pre-fix this returned
+  // `dm` — the agent's own message delivered back to it as fresh inbound.
+  const v = resolveDirected(c, ME_SLUG, f, { meAliases: [ME_SLUG, ME] });
+  assert.equal(v.directed, false);
+  assert.equal(v.reason, "own_echo");
+});
+
+test("REGRESSION: a SLUG-shaped actor is suppressed when me is the cuid", () => {
+  const f = withChannel(facts(), "C-dm", "DM");
+  const c = classifyEvent(
+    ev({ family: "messaging", kind: "send", actor: ME_SLUG, entity_id: "m1", payload: { actor: ME_SLUG, channelId: "C-dm", channelKind: "DM" } }),
+  );
+  // Symmetric: suppression must not depend on WHICH namespace either side used.
+  assert.equal(resolveDirected(c, ME, f, { meAliases: [ME, ME_SLUG] }).reason, "own_echo");
+});
+
+test("meAliases widen own-echo ONLY — never reach", () => {
+  const f = facts(); // C-theirs is in nobody's roster but its members'
+  const c = classifyEvent(
+    ev({ family: "messaging", kind: "send", entity_id: "m1", payload: { actor: THEM, channelId: "C-theirs", channelKind: "DM" } }),
+  );
+  const v = resolveDirected(c, ME_SLUG, f, { meAliases: [ME_SLUG, ME] });
+  assert.equal(v.directed, false, "an alias list must never open someone else's room");
+  assert.equal(v.reason, "channel_not_visible");
+});
+
+test("a blank/garbage alias never swallows real inbound", () => {
+  const f = withChannel(facts(), "C-dm", "DM");
+  withMessage(f, "C-dm", { id: "m1", authorId: THEM, body: "ping" });
+  const c = classifyEvent(
+    ev({ family: "messaging", kind: "send", entity_id: "m1", payload: { actor: THEM, channelId: "C-dm", channelKind: "DM", mentionCount: 0, threaded: false } }),
+  );
+  // Empty strings and nullish entries are dropped, so `has(actor)` cannot match
+  // on emptiness and turn every message into my own echo.
+  const v = resolveDirected(c, ME, f, { meAliases: [null, "", "   ", undefined] });
+  assert.deepEqual({ d: v.directed, r: v.reason }, { d: true, r: "dm" });
+});
+
 // ---------------------------------------------------------------------------
 // messaging — DM / mention / thread / ambient
 // ---------------------------------------------------------------------------

package/lib/org/inbound/index.mjs

@@ -87,6 +87,8 @@ const DEFAULT_EVENT_LIMIT = 200;
  * @param {number} [o.limit]
  * @param {Function} [o.fetchImpl]
  * @param {string[]} [o.myNames]               display names for prose-mention matching
+ * @param {string[]} [o.meAliases]             other identity strings for this seat
+ *   (slug, member id) — widens OWN-ECHO suppression only, never reach
  * @param {string[]|Record<string,boolean>} [o.surfaces] surface enable override
  * @param {object} [o.limits]                  overrides for {@link DEFAULT_LIMITS}
  * @param {Function} [o.log]                   (level, message, meta?) — daemon logger
@@ -125,6 +127,11 @@ export async function pullWideInbound(o = {}) {
     return empty;
   }
 
+  // Extra identity strings for own-echo suppression only (slug AND member id).
+  // The caller cannot always know which namespace `agentId` is in; passing both
+  // means a slug-valued COHORT_AGENT_ID can never silently disable the drop.
+  const meAliases = Array.isArray(o.meAliases) ? o.meAliases.filter(Boolean) : [];
+
   const { enabled, unknown } = resolveEnabledSurfaces(
     o.surfaces !== undefined ? o.surfaces : parseSurfaceEnv(process.env.COHORT_INBOUND_SURFACES),
   );
@@ -185,7 +192,7 @@ export async function pullWideInbound(o = {}) {
   // ── 3. Verdicts.
   const directed = [];
   for (const cand of candidates) {
-    const verdict = resolveDirected(cand, me, facts, { enabled });
+    const verdict = resolveDirected(cand, me, facts, { enabled, meAliases });
     if (!verdict.directed) {
       stats.dropped[verdict.reason] = (stats.dropped[verdict.reason] || 0) + 1;
       continue;

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

@@ -208,6 +208,28 @@ test("NEGATIVE: nothing from someone else's private room, my own echo, or ambien
   assert.ok(stats.dropped.channel_not_visible >= 1);
 });
 
+test("REGRESSION: a slug-valued agentId still drops my own echo, via meAliases", async () => {
+  // The production shape on 2026-08-26: COHORT_AGENT_ID is a SLUG, hq stamps
+  // `actor` with the member cuid. `agentId` alone then matches nothing and the
+  // own-echo drop silently stops existing — no throw, no log, just the seat
+  // answering itself. The daemon hands BOTH namespaces down as `meAliases`, so
+  // the drop survives regardless of which one `agentId` resolved to.
+  const io = fakeIo(routes());
+  const { events, stats } = await pullWideInbound({
+    cfg: CFG,
+    agentId: "A028",
+    meAliases: ["A028", ME],
+    io,
+  });
+
+  assert.ok(stats.dropped.own_echo >= 1, "own_echo must still fire when me is the slug");
+  assert.equal(
+    events.some((e) => e.message_id === "m-mine"),
+    false,
+    "my own message must never come back, whichever id namespace the caller passed",
+  );
+});
+
 test("email is OFF by default and is not even hydrated", async () => {
   const io = fakeIo(routes());
   const { events } = await pullWideInbound({ cfg: CFG, agentId: ME, io });

package/lib/org/mesh-directives.test.mjs

@@ -0,0 +1,110 @@
+/**
+ * mesh-directives.test.mjs — the two front-door directives (design §3.4 /
+ * audit F10): hq's `remediateFleetSeat` queues `restart` and nothing honoured
+ * it. Now:
+ *
+ *   restart          → the daemon flushes and exits NON-ZERO so launchd's
+ *                      KeepAlive {SuccessfulExit:false} relaunches it (a clean
+ *                      exit 0 would leave it down). Injected as requestRestart.
+ *   session.restart  → touch state/session/restart-requested; the session's
+ *                      feed sees it and the session restarts itself at an idle
+ *                      moment. The daemon is untouched.
+ *
+ * Driven through the same fake client + explicit beatOnce as mesh.test.mjs.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { connectOrgMesh, _internals } from "./mesh.mjs";
+
+const BASE = "https://org.cohortapp.com";
+function tmpRepo() {
+  const root = mkdtempSync(join(tmpdir(), "org-mesh-directives-"));
+  mkdirSync(join(root, "config"), { recursive: true });
+  writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Alex", fullName: "Alex Chen", repoSlug: "alex-ai" }));
+  return root;
+}
+function cfgEnabled() { return { org: { cohort: { enabled: true, base: BASE, token: "tok" } } }; }
+function fakeClient(beatFrames) {
+  const c = {
+    isEnabled: (cfg) => !!(cfg && cfg.org && cfg.org.cohort && cfg.org.cohort.enabled),
+    configFromAgent: () => ({ base: BASE, token: "tok", orgId: "", enabled: true, trustedSignersPem: [] }),
+    _beatFrames: beatFrames.slice(),
+    register() { return Promise.resolve({ ok: true, result: { status: 200 } }); },
+    presenceBeat() { return Promise.resolve(c._beatFrames.length ? c._beatFrames.shift() : { ok: true, result: { directives: [] } }); },
+    fetchDirectory() { return Promise.resolve({ ok: true, result: { agents: [] } }); },
+    call() { return Promise.resolve({ ok: true, result: {} }); },
+  };
+  return c;
+}
+
+test("KNOWN_DIRECTIVES includes restart and session.restart", () => {
+  assert.ok(_internals.KNOWN_DIRECTIVES.has("restart"));
+  assert.ok(_internals.KNOWN_DIRECTIVES.has("session.restart"));
+});
+
+test('"restart" directive stops the beat loop and asks the daemon to restart (exit non-zero); never writes .emergency-stop', async () => {
+  const root = tmpRepo();
+  const client = fakeClient([{ ok: true, result: { directives: ["restart"] } }]);
+  let stops = 0;
+  let restarts = 0;
+  const handle = await connectOrgMesh({
+    agentRoot: root, cfg: cfgEnabled(), client,
+    setInterval: () => ({ unref() {} }),
+    requestStop: () => { stops += 1; },
+    requestRestart: () => { restarts += 1; },
+  });
+  const directives = await _internals.beatOnce(handle._ctx);
+  assert.deepEqual(directives, ["restart"]);
+  assert.equal(restarts, 1, "requestRestart() was invoked");
+  assert.equal(stops, 0, "a restart is not a halt");
+  assert.equal(existsSync(join(root, ".emergency-stop")), false, "a restart must never trip the kill switch");
+  assert.equal(handle._ctx.stopped, true, "the beat loop stopped: the process is going down to come back");
+});
+
+test('"session.restart" directive touches state/session/restart-requested and leaves the daemon running', async () => {
+  const root = tmpRepo();
+  const client = fakeClient([{ ok: true, result: { directives: ["session.restart"] } }]);
+  let stops = 0;
+  let restarts = 0;
+  const T0 = Date.parse("2026-09-08T10:00:00.000Z");
+  const handle = await connectOrgMesh({
+    agentRoot: root, cfg: cfgEnabled(), client,
+    setInterval: () => ({ unref() {} }),
+    now: () => T0,
+    requestStop: () => { stops += 1; },
+    requestRestart: () => { restarts += 1; },
+  });
+  const directives = await _internals.beatOnce(handle._ctx);
+  assert.deepEqual(directives, ["session.restart"]);
+  const flag = join(root, "state", "session", "restart-requested");
+  assert.ok(existsSync(flag), "restart-requested flag written");
+  assert.match(readFileSync(flag, "utf8"), /2026-09-08T10:00:00/, "flag carries the request time");
+  assert.equal(stops, 0);
+  assert.equal(restarts, 0, "the daemon itself is not restarted");
+  assert.equal(handle._ctx.stopped, false, "the beat loop keeps running");
+  // Idempotent: a second directive overwrites the flag, never throws.
+  await _internals.handleDirective("session.restart", handle._ctx);
+  assert.ok(existsSync(flag));
+});
+
+test("the default restart signal sets a non-zero exit code before the graceful stop, so launchd relaunches", () => {
+  // defaultRequestRestart is the production path; we only check its contract
+  // on process.exitCode without sending ourselves a signal.
+  const prevExitCode = process.exitCode;
+  const prevKill = process.kill;
+  let killed = null;
+  process.kill = (pid, sig) => { killed = { pid, sig }; return true; };
+  try {
+    _internals.defaultRequestRestart();
+    assert.equal(process.exitCode, 1, "exit code 1 → KeepAlive {SuccessfulExit:false} brings the daemon back");
+    assert.deepEqual(killed, { pid: process.pid, sig: "SIGTERM" }, "graceful stop via the daemon's own SIGTERM handlers (flush)");
+  } finally {
+    process.kill = prevKill;
+    process.exitCode = prevExitCode;
+  }
+});