@commonlyai/cli 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

package/src/commands/agent.js

@@ -803,6 +803,40 @@ export const performRun = ({
     // capped agent-triggered event is exactly the traffic we want dropped.
     // Human-triggered turns are never capped.
     const trigger = classifyTrigger(event, preSpawn);
+    // A human turn is a property of the POD, not of this seat's reaction to
+    // it. Record it as soon as it is classified — before the cascade check and
+    // before the claim race — so a seat that stands down still observes the
+    // reset.
+    //
+    // Without this, losing a claim on a human message is SELF-REINFORCING.
+    // The claim stand-down returns before `runTurn`, and `record()` lives at
+    // the end of `runTurn`, so the loser never records the human turn that
+    // would have cleared its streak. It meets the next broadcast still capped,
+    // declines, and again skips `record()`. The only other escape is the
+    // seat's own resetMs clock: stateFor reads only this process's
+    // lastAgentTurnAt, so a capped seat self-clears 10 minutes after its last
+    // completed agent turn regardless of room traffic — cyclical throttling,
+    // not permanent starvation.
+    //
+    // Measured in one pod, 2026-08-18, same window: ux-lead 14 lost claims /
+    // 73 cap refusals / 2 posts, against sprint-review 0 / 2 / 95. Losing one
+    // race is what kept it losing — the mechanism meant to SHARE work
+    // concentrated it instead.
+    //
+    // `=== 'human'` rather than `!== 'agent'`. These are behaviourally the
+    // same today: `record()` dispatches on exact equality and leaves every
+    // other value untouched, including the 'unknown' that `classifyTrigger`
+    // returns for an unresolvable trigger — `enforcement.js:123-131`, and the
+    // "'unknown' is neutral: no count, no reset" note at :130. The narrow form
+    // is defensive, not load-bearing: it keeps an unidentifiable event from
+    // becoming a cap-reset primitive if `record()` ever grows a fallthrough
+    // branch. It closes no hole that was open.
+    //
+    // Agent-triggered turns still record only on completion (see `runTurn`),
+    // so the no-double-count property for redelivered events is unchanged.
+    // Recording a human trigger sets the streak to 0, so this call and the
+    // completion-time one are idempotent with each other.
+    if (trigger === 'human') cascadeGovernor.record(eventPodId, trigger);
     const admission = cascadeGovernor.admit(eventPodId, trigger, event.type);
     if (!admission.allowed) {
       log(
@@ -987,7 +1021,34 @@ export const performRun = ({
       }
     } else if (silentReply) {
       const reason = heartbeatControlReply ? replyText : (replyText || 'empty output');
-      log(`[${event.type}] no wrapper-post (${reason})`);
+      // A turn that posted via tool and THEN ended with the sentinel is not the
+      // same event as a turn that produced nothing — but this branch reported
+      // both as `no wrapper-post (NO_REPLY)`, because it is evaluated before
+      // the `agentPostedItself` branch below and swallowed that fact.
+      //
+      // The skill told agents to do exactly this (post via commonly_post_message,
+      // then end with NO_REPLY so the wrapper does not double-post), so CORRECT
+      // behaviour and total silence were indistinguishable on stdout.
+      //
+      // Cost, 2026-08-18: a seat was diagnosed as mute for "19 hours" on the
+      // strength of `grep -c "posted via tool" == 0` against its log. It had in
+      // fact posted seven times in that window. Five remedies were applied to a
+      // seat that was never broken — cleared session, fresh process, MCP
+      // repointed, model repinned — before the seat itself pointed at the
+      // ledger. The instrument was broken, not the agent.
+      //
+      // Report the two cases distinctly. `posted` is the load-bearing word: a
+      // reader scanning for whether a seat is contributing must not have to
+      // infer it from the absence of a different line.
+      if (agentPostedItself) {
+        log(
+          `[${event.type}] posted via tool, then ${reason} — no echo needed `
+          + `(matched message ${suppressedBy.id} by ${suppressedBy.author} `
+          + `via ${suppressedBy.basis})`,
+        );
+      } else {
+        log(`[${event.type}] no wrapper-post (${reason}) — nothing posted this turn`);
+      }
     } else if (agentPostedItself) {
       // Name the message that caused the suppression. A silently dropped reply
       // is invisible to everyone; #757 went unnoticed precisely because this

package/src/lib/enforcement.js

@@ -75,11 +75,10 @@ export const ADDRESSED_EVENT_TYPES = new Set(['chat.mention', 'thread.mention',
  * pod recovers on its own — a legitimate a2a handoff an hour later must not
  * inherit a stale cap).
  *
- * NOTE on `resetMs`: it is a SILENCE window, not a decay. It requires
- * `resetMs` with ZERO agent-triggered turns in the pod. Three chatty seats
- * never leave a ten-minute hole, so in a busy room the only live release is a
- * human turn. Say so plainly rather than letting "or the streak decays" imply
- * a timer that will save you.
+ * The only other escape is the seat's own resetMs clock: stateFor reads only
+ * this process's lastAgentTurnAt, so a capped seat self-clears 10
+ * minutes after its last completed agent turn regardless of room traffic —
+ * cyclical throttling, not permanent starvation.
  *
  * Split into admit/record so a spawn that fails (and will be redelivered)
  * never double-counts: admit() only reads, record() runs after a turn