@cohortapp/agent-sdk 2.18.18 → 2.18.20

package/lib/assurance/first-reply.mjs

@@ -421,3 +421,65 @@ export default {
   firstReplyPlan,
   stampFirstReplyPlan,
 };
+
+/**
+ * The AGENT STATUS NOTICE family — a seat narrating its own progress, failure
+ * or recovery to a room.
+ *
+ * ── WHY THIS EXISTS, AND WHY IT IS SEPARATE FROM THE RETIRED REGISTER ───────
+ *
+ * The register above answers "may this seat SEND this line?". This answers a
+ * different question: "is this line, arriving from ANOTHER seat, a piece of
+ * work?" — and the answer is always no. A colleague saying how their own task
+ * went is a status report. It is not an ask, and it must never mint a board row.
+ *
+ * On 2026-09-30 it did. `assurance.isOwnNarratorText` already recognised these
+ * notices, but only for SELF-echo — a seat ignoring its own words. Nothing
+ * stopped Jacob's recovery notice reaching Candace as an ordinary message, and
+ * with no `--title` on the claim the row took the ask's own first sentence as
+ * its title. Production, in three hours:
+ *
+ *   "Here's where I got to: Archived, logged."
+ *   "Here's where I got to: Declined, logged, no reply."
+ *   "Here's where I got to: Here's where I got to: Queued, not archived …"
+ *
+ * Sixty-four rows, several seats each opening and closing the same non-task,
+ * and the doubled title is the output of the path re-entering its own input —
+ * a row minted from a report ABOUT a row. One of them read "eleventh turn".
+ *
+ * FROZEN LITERALS for the same reason the register above is frozen: a notice
+ * arriving from a seat that has not upgraded yet must still be recognised long
+ * after the local composer that produced it has changed.
+ */
+const STATUS_NOTICE_PATTERNS = Object.freeze([
+  // composeSilentSuccess — the recovery notice, with or without an excerpt.
+  // The excerpt is unbounded prose, so this anchors on the head alone.
+  /^finished this but didn'?t get a reply out to you\s*[—–-]\s*my fault\b/i,
+  // composeInterrupted.
+  /^heads up\s*[—–-]\s*my session on this was interrupted\b/i,
+  // notice-voice's generated failure/progress lines, which name the topic:
+  //   The work on "X" broke before it finished: …
+  //   The work on "X" didn't get through: …
+  /^the work (on ".+?"|you asked for)\s+(broke|didn'?t|never|has)\b/i,
+  // The board-status shape that closed the loop on itself.
+  /^here'?s where i got to:/i,
+]);
+
+/**
+ * Is this body a seat narrating its own work, rather than asking for any?
+ *
+ * Judged per PARAGRAPH like the register above, because these notices are
+ * routinely concatenated with an excerpt or with each other.
+ *
+ * @param {unknown} body
+ * @returns {boolean}
+ */
+export function isAgentStatusNotice(body) {
+  const paras = String(body == null ? "" : body).split(/\n\s*\n/);
+  for (const p of paras) {
+    const line = normaliseLine(p);
+    if (!line) continue;
+    if (STATUS_NOTICE_PATTERNS.some((re) => re.test(line))) return true;
+  }
+  return false;
+}

package/lib/channels/inbox-item.mjs

@@ -120,7 +120,7 @@ export function yamlScalar(s) {
 const QUOTED_SCALAR_FIELDS = [
   "id", "service", "channel", "channel_id", "sender", "sender_id",
   "sender_privilege", "timestamp", "subject", "thread_id", "raw_ref", "kind",
-  "event_kind", "direct_reason", "scope_id", "channel_kind", "channel_type",
+  "event_kind", "author_kind", "direct_reason", "scope_id", "channel_kind", "channel_type",
   "event_type",
 ];
 
@@ -279,6 +279,22 @@ export function eventToInboxItem(ev) {
     item.event_kind = sanitizeYamlField(chainKind);
   }
 
+  // THE AUTHOR'S KIND ("HUMAN" | "AI_AGENT"), by the same rule and for a
+  // measured reason. `lib/org/work-ledger.mjs` sends `authorKind` to hq's board
+  // gate, whose clause 2 refuses a row for an agent author; this converter
+  // enumerates its fields, so before this line the kind `project.mjs` resolved
+  // died HERE and the ledger's `undefined` became the string "HUMAN". Every seat
+  // therefore asserted a human author for every ask — which is how an agent's
+  // own "Archived, logged." minted board rows on 2026-09-30.
+  //
+  // Read off the event, not the org projection: `project.mjs` stamps it at top
+  // level next to `sender`, and only when `facts.memberKinds` PROVED it. An
+  // unknown kind stays absent rather than defaulting, because a wrong assertion
+  // here would cost a legitimate row.
+  if (ev.author_kind === "HUMAN" || ev.author_kind === "AI_AGENT") {
+    item.author_kind = ev.author_kind;
+  }
+
   // THE DIRECTEDNESS REASON, for the same reason and by the same rule.
   //
   // `lib/org/inbound/directedness.mjs` does real work to answer WHY an event is

package/lib/org/inbound/project.mjs

@@ -36,6 +36,7 @@
 "use strict";
 
 import { SURFACES } from "./surfaces.mjs";
+import { authorKindOf } from "./directedness.mjs";
 
 /** Blank-safe string. */
 function s(v) {
@@ -88,6 +89,8 @@ export function toMessageEvent(o = {}) {
   const subject = subjectDetail ? `${def.subject}: ${subjectDetail}` : def.subject;
 
   const from = resolveFrom(hydrated, c, facts);
+  // "" when the directory read degraded — see the note at `author_kind` below.
+  const authorKind = authorKindOf(facts, from.id);
   const scope = scopeFor(verdict.surface, channelKind, def.scope);
 
   const ev = {
@@ -114,6 +117,26 @@ export function toMessageEvent(o = {}) {
     channel_id: channelId,
     channel_label: channelLabel,
     sender: s(from.name || from.id),
+    // THE AUTHOR'S KIND, when the directory PROVES it.
+    //
+    // hq's board gate (`src/server/work/threshold.ts` clause 2) refuses a row
+    // for an AI_AGENT author — "agent↔agent chatter is coordination, not a work
+    // request" — and that clause was UNREACHABLE from this plane for as long as
+    // it has existed. Nothing on a seat machine ever set an author kind, so
+    // `lib/org/work-ledger.mjs` turned the resulting `undefined` into the string
+    // "HUMAN" and every seat asserted a human author for every ask, always. On
+    // 2026-09-30 that let each seat's own closing status line ("Archived,
+    // logged.") mint a board row in an agent↔agent DM, a row every eighty
+    // seconds for eleven turns, titled with the raw sentence.
+    //
+    // `facts.memberKinds` is the one `member.list` the facts pass already makes,
+    // keyed by member id AND slug. OMITTED, never guessed, when that read
+    // degraded (`authorKindOf` returns "") — an absent field keeps the previous
+    // shape exactly, and hq now resolves the kind server-side from the message
+    // row anyway, so a blank here costs nothing and a WRONG value here would
+    // cost the refusal. This field is the poll lane's defence in depth, not the
+    // load-bearing guard.
+    ...(authorKind ? { author_kind: authorKind } : {}),
     is_reply: Boolean(hydrated.isReply),
     thread_context: hydrated.threadContext != null ? hydrated.threadContext : null,
     // VOICE_NOTE_OVERLAY (2026-09-26): attachment metadata from the hydrator rides on the event so

package/lib/org/work-ledger.mjs

@@ -204,6 +204,34 @@ export async function recordWorkStep(a = {}) {
       // refused by name, and a seat that got its local classifier wrong loses a
       // well-shaped prompt rather than opening a row it should not have.
       collective: isRollCallItem(a.item),
+      // THE AUTHOR'S KIND, and WHAT THIS LINE CAN AND CANNOT SEE.
+      //
+      // hq's `work/threshold.ts` clause 2 refuses a row for an AI_AGENT author.
+      // Until 2026-09-30 this line could only ever produce "HUMAN": nothing on a
+      // seat machine set `author_kind`, so the field was structurally
+      // unreachable and the fallback below was the only branch that ran. Every
+      // seat asserted a human author for every ask, the clause never fired, and
+      // each seat's own closing status line ("Archived, logged.") minted a board
+      // row in an agent↔agent DM — one every eighty seconds for eleven turns.
+      //
+      // `lib/org/inbound/project.mjs` now stamps the kind from
+      // `facts.memberKinds`, and it survives the YAML round trip
+      // (`lib/channels/inbox-item.mjs` → `scripts/poller/utils.mjs` →
+      // `scripts/poller/inbox-scan-poller.mjs`);
+      // `lib/org/inbound/author-kind.test.mjs` pins that end to end, because an
+      // unreachable field is exactly the drift that made this line lie for as
+      // long as it existed. (That citation read `inbound-author-kind.test.mjs`,
+      // a file that has never existed — the same prose-vs-executable drift this
+      // comment is warning about, inside the comment whose job is to stop it.
+      // Written as a REPO-ROOT-RELATIVE PATH now, so `grep` finds it or fails.)
+      //
+      // STILL NOT THE LOAD-BEARING GUARD, deliberately. The fallback is "HUMAN"
+      // rather than "unknown" because a degraded directory read must not cost a
+      // real ask its row, and hq re-resolves the kind SERVER-SIDE from the
+      // message row regardless of what this says — an authenticated caller may
+      // not assert that a message another member wrote was written by a person.
+      // This is defence in depth for the poll lane: right when we know, silent
+      // when we do not, and never the thing the invariant rests on.
       authorKind: a.item && a.item.author_kind === "AI_AGENT" ? "AI_AGENT" : "HUMAN",
       deferred: a.deferred === true,
     };

package/lib/session/ask-ledger.mjs

@@ -215,6 +215,28 @@ export function ledgerStepsFor(a = {}) {
  * @returns {Promise<{steps:Array<object>, results:Array<object>}>}
  */
 export async function runAskLedger(a = {}) {
+  // ── A STATUS REPORT IS NOT WORK ──────────────────────────────────────────
+  //
+  // A colleague narrating how their own task went is not an ask, and a row
+  // opened from one is a row nobody requested. On 2026-09-30 this minted 64
+  // rows in three hours — titled "Here's where I got to: Archived, logged."
+  // and once "Here's where I got to: Here's where I got to: …", which is a row
+  // minted from a report ABOUT a row. Several seats each opened and closed the
+  // same non-task; one row's note read "eleventh turn".
+  //
+  // The notice family was already recognised (`assurance.isOwnNarratorText`)
+  // but only for SELF-echo, so a seat ignored its own words and happily
+  // actioned everyone else's. This applies the same recognition to the question
+  // that matters here: not "did I say this?" but "is this work?".
+  //
+  // Deliberately at the LEDGER, not at ingestion: the seat should still READ a
+  // colleague's status notice and may still reply to it. What it must not do is
+  // open a board row for it.
+  const { isAgentStatusNotice } = await import("../assurance/first-reply.mjs");
+  const body = (a.item && (a.item.content || a.item.subject)) || a.text || "";
+  if (isAgentStatusNotice(body)) {
+    return { steps: [], results: [{ tracked: false, reason: "status-notice-not-an-ask" }] };
+  }
   const steps = ledgerStepsFor(a);
   const results = [];
   if (steps.length === 0) return { steps, results };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.18.18",
+  "version": "2.18.20",
   "description": "Cohort Agent SDK — autonomous AI colleague runtime. Deploy senior AI colleagues on dedicated Mac minis, wired to the Cohort operating surface.",
   "type": "module",
   "bin": {

package/scripts/poller/inbox-scan-poller.mjs

@@ -124,6 +124,15 @@ export function parseInboxItemYaml(body) {
   // obligation binds identically on the push and poll lanes.
   const eventKind = scalar("event_kind");
   if (eventKind) item.event_kind = eventKind;
+
+  // THE AUTHOR'S KIND, read back for `lib/org/work-ledger.mjs` → hq's board
+  // gate. Only the two values the gate understands are accepted: an item whose
+  // `author_kind` is junk is treated as UNKNOWN (absent) rather than passed
+  // through, so a malformed line cannot assert an author kind hq would trust.
+  const authorKind = scalar("author_kind");
+  if (authorKind === "HUMAN" || authorKind === "AI_AGENT") {
+    item.author_kind = authorKind;
+  }
   // The directedness verdict's own reason, and the surface's subject id. Same
   // rule as `event_kind`: attached only when the writer knew, so a non-org item
   // keeps exactly its old shape. `intake.fromInboxItem` PREFERS `direct_reason`

package/scripts/poller/utils.mjs

@@ -178,7 +178,7 @@ function renameLiveInbox(item, service, agentRoot, suffix) {
 const YAML_SAFE_SCALARS = [
   "id", "service", "channel", "channel_id", "sender", "sender_id",
   "sender_privilege", "timestamp", "subject", "thread_id", "raw_ref", "kind",
-  "event_kind", "direct_reason", "scope_id", "channel_kind", "channel_type",
+  "event_kind", "author_kind", "direct_reason", "scope_id", "channel_kind", "channel_type",
   "event_type",
 ];
 
@@ -255,6 +255,19 @@ raw_ref: "${item.raw_ref || ""}"
     yaml += `event_kind: "${item.event_kind}"\n`;
   }
 
+  // THE AUTHOR'S KIND, written only when the projection PROVED it, by the same
+  // "absent means unknown" rule as `kind` and `event_kind` above.
+  //
+  // This writer enumerates its fields, as the note above says — so the kind that
+  // `lib/org/inbound/project.mjs` resolves from `facts.memberKinds` died at this
+  // boundary, and `lib/org/work-ledger.mjs` then told hq's board gate "HUMAN"
+  // for every ask any seat ever saw. hq's gate refuses a row for an AI_AGENT
+  // author; unreachable from the poll lane, it could not refuse the agent↔agent
+  // status lines that minted a board row every eighty seconds on 2026-09-30.
+  if (item.author_kind) {
+    yaml += `author_kind: "${item.author_kind}"\n`;
+  }
+
   // THE DIRECTEDNESS REASON and THE SURFACE'S SUBJECT ID, for exactly the reason
   // above: this writer enumerates its fields, so anything not named here dies at
   // the YAML boundary and the poll lane behaves differently from the push lane.