@cohortapp/agent-sdk 2.11.3 → 2.11.5

package/lib/budget-guard.mjs

@@ -663,7 +663,21 @@ export function dailyAllowance(deps) {
  * @param {object} [deps] { now?, ledgerDir?, agentRoot?, capUSD?, iterationCap?,
  *                          seatEnvelope?, mandateCachePath?, log? }
  */
+/**
+ * Is this seat authenticated by a flat-fee Max SUBSCRIPTION (not the metered
+ * API)? A subscription seat has no dollar meter: the CLI's `total_cost_usd` is
+ * API-EQUIVALENT, not spend, and every session reports "unmeasured" by design —
+ * that is normal, not a telemetry outage. Banding such a seat on dollars
+ * suspends a seat that costs a flat fee, stops its autonomous work, and floods
+ * the log every tick. `deps.subscriptionAuth` overrides for tests.
+ */
+export function isSubscriptionAuth(deps) {
+  if (deps && typeof deps.subscriptionAuth === "boolean") return deps.subscriptionAuth;
+  return process.env.MAESTRO_PREFER_SUBSCRIPTION_AUTH === "1" && !process.env.ANTHROPIC_API_KEY;
+}
+
 export function dailyStatus(deps) {
+  const subscriptionAuth = isSubscriptionAuth(deps);
   const iterationCap = cfgIterationCap(deps);
   const today = sumToday(deps);
   const { spentUSD, sessions } = today;
@@ -708,15 +722,23 @@ export function dailyStatus(deps) {
   // The binding constraint is whichever is closest to (or furthest past) the cap.
   // A null day-reading contributes nothing; the exhausted-envelope case is
   // already ≥100 % on the month, so nothing is lost by skipping it.
-  const pct = Math.max(spendPct ?? 0, monthPct, iterPct);
+  // A subscription-auth seat has no dollar meter (see isSubscriptionAuth): its
+  // dollar "spend" is API-equivalent fiction, so banding on it wrongly suspends a
+  // flat-fee seat and halts its autonomous work. Band it on SESSION VOLUME only
+  // (a real limit); concurrency (resource-governor) + the 429 rate-breaker are
+  // its other guards.
+  const pct = subscriptionAuth
+    ? iterPct
+    : Math.max(spendPct ?? 0, monthPct, iterPct);
   let band = bandForPct(pct);
 
   // ── BLIND ⇒ DEGRADE ────────────────────────────────────────────────────────
   // `blind` (sessions ran, none measured) was computed and reported and enforced
   // by nothing. It is now load-bearing: we do not invent a price, we lower the
   // rung. Only when the day is TRULY unpriceable — if a month mean was available
-  // the spend was imputed from it and the ordinary band applies.
-  if (today.blind && today.unpriceable && band < BLIND_MIN_BAND) {
+  // the spend was imputed from it and the ordinary band applies. Does NOT apply
+  // to subscription auth, where "unmeasured" is the normal, expected state.
+  if (!subscriptionAuth && today.blind && today.unpriceable && band < BLIND_MIN_BAND) {
     extraDegradations.push(
       `band raised ${band}% → ${BLIND_MIN_BAND}%: ${today.unmeasuredSessions} session(s) ran today and NONE could be ` +
       "measured or priced. An unmeasurable seat is degraded, not trusted."
@@ -725,7 +747,16 @@ export function dailyStatus(deps) {
   }
   const posture = postureForBand(band);
 
-  const degradations = [...today.degradations, ...allowance.degradations, ...extraDegradations];
+  let degradations = [...today.degradations, ...allowance.degradations, ...extraDegradations];
+  // On a subscription seat the dollar-meter degradations (imputed / unmeasured /
+  // unfunded-envelope / telemetry) are irrelevant — there is no dollar meter —
+  // and were logged EVERY tick, burying real signal (a DM not answered) under a
+  // flood. Drop them; keep any non-dollar note (e.g. a malformed ledger line).
+  if (subscriptionAuth) {
+    degradations = degradations.filter(
+      (d) => !/imputed|unmeasured|unpriceable|UNFUNDED SEAT|envelope|per-session|telemetry|blind/i.test(String(d)),
+    );
+  }
   // Degradations ride on the returned status AND go to the log: the daemon is
   // usually the only thing awake when telemetry breaks, and a governor that
   // quietly under-counts is the failure mode this module now exists to prevent.

package/lib/budget-guard.test.mjs

@@ -338,3 +338,28 @@ test("a ledger of only zero-token rows sums to $0 (proves the bug is the input,
     assert.equal(s.sessions, 2);
   } finally { await rm(dir); }
 });
+
+test("dailyStatus: a subscription-auth seat is banded on session VOLUME, not dollars", async () => {
+  const dir = await makeLedgerDir();
+  try {
+    seedLedger(dir, [{ usd: 40 }]); // $40 of $10 = 400%
+    // A metered (API) seat: dollars bind → band 150 (refused).
+    assert.equal(dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10, iterationCap: 100 }).band, 150);
+    // A flat-fee subscription seat has no dollar meter — the same API-equivalent
+    // "spend" is fiction. It lands at band 0 / normal so autonomous work keeps
+    // running; only session VOLUME can band it.
+    const sub = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 10, iterationCap: 100, subscriptionAuth: true });
+    assert.equal(sub.band, 0);
+    assert.equal(sub.mode, "normal");
+  } finally { await rm(dir); }
+});
+
+test("dailyStatus: a subscription-auth seat STILL bands on session volume (a real limit)", async () => {
+  const dir = await makeLedgerDir();
+  try {
+    seedLedger(dir, Array.from({ length: 12 }, () => ({ usd: 0.01 }))); // 12 sessions
+    const sub = dailyStatus({ ledgerDir: dir, now: clk, capUSD: 1000, iterationCap: 10, subscriptionAuth: true });
+    assert.equal(sub.band, 100, "12 sessions / cap 10 = 120% → degrade even on subscription");
+    assert.equal(sub.mode, "degraded");
+  } finally { await rm(dir); }
+});

package/lib/resource-governor.mjs

@@ -16,14 +16,26 @@
  * never dropped — and the agent throttles instead of bricking.
  *
  * Dynamic ceiling (replaces the hardcoded MAX_CONCURRENT=10):
- *   dynamicMax  = clamp(floor(totalmem * 0.60 / 750MB), 1, min(10, cpus))
+ *   dynamicMax  = clamp(floor(totalmem * 0.60 / 750MB), 1, min(HARD_MAX, cpus))
  *   effectiveMax = min(dynamicMax, throttleCeiling)
  * where throttleCeiling comes from state/throttle.json (written by the memory
  * watchdog's SOFT tier; auto-expiring). The governor only READS that file —
- * it never writes it.
+ * it never writes it. HARD_MAX defaults to 4, not 10: the binding constraint on
+ * a subscription-auth seat is the ONE Max subscription, which cannot serve many
+ * parallel `claude --print` calls — ten concurrent sessions starved the reactive
+ * quick-reply's claude call into a 60s timeout. API/multi-key deployments raise
+ * it with GOV_HARD_MAX.
+ *
+ * The concurrency ceiling is PER SOURCE, because a dispatch slot is not the
+ * scarce resource — the subscription + host CPU are. Reactive work (inbox / a
+ * direct human or agent reply) may use the WHOLE envelope; self-directed backlog
+ * is held REACTIVE_RESERVE (default 2) slots short so a reply can always be
+ * GENERATED, not merely dispatched. This is the governor-level twin of the
+ * dispatcher's RESERVED_INBOX_SLOTS (which reserves a dispatch slot).
  *
  * Thresholds (env GOV_* overridable; tests inject `deps` instead):
- *   liveCount >= effectiveMax                         → QUEUE
+ *   inbox   liveCount >= effectiveMax                  → QUEUE
+ *   backlog liveCount >= effectiveMax - REACTIVE_RESERVE → QUEUE
  *   freemem < totalmem*0.15  OR  < 2*750MB headroom    → DEFER
  *   loadavg1 > cpus*1.5                                → DEFER
  *   liveRSS + 750MB > 0.60*totalmem                    → QUEUE
@@ -31,7 +43,9 @@
  *
  * Plus the budget ladder (`mode`, from `lib/budget-guard.dailyStatus().mode`),
  * banded against the seat's hq-funded envelope rather than a local config cap:
- *   degraded  (≥100%)  source==="backlog"            → DEFER (D3 stops)
+ *   degraded  (≥100%)  source==="backlog"  → THROTTLE to DEGRADED_BACKLOG_MAX
+ *                                            (default 1) — a trickle in idle gaps,
+ *                                            not a stop (owner instruction).
  *   suspended (≥125%)  source==="backlog"|"cadence"  → DEFER
  *   refused   (>150%)  anything that is not a direct human reply → DEFER
  * Inbox always goes through the normal ADMIT/QUEUE path — never go dark on the
@@ -64,8 +78,29 @@ export const RAM_FRACTION = frac(process.env.GOV_RAM_FRACTION, 0.6);
 export const FREEMEM_FLOOR_FRACTION = frac(process.env.GOV_FREEMEM_FLOOR, 0.15);
 /** Load-average multiplier over cpu count that triggers a DEFER. */
 export const LOAD_FACTOR = num(process.env.GOV_LOAD_FACTOR, 1.5);
-/** Hard ceiling on dynamicMax regardless of RAM. */
-export const HARD_MAX = num(process.env.GOV_HARD_MAX, 10);
+/**
+ * Hard ceiling on dynamicMax regardless of RAM. The binding constraint on a
+ * subscription-auth seat is NOT host RAM — it is the ONE Max subscription, which
+ * cannot serve many parallel `claude --print` calls without throttling. Ten
+ * concurrent backlog sessions starved the reactive quick-reply's claude call
+ * into a 60s timeout (observed on A016/isla). Default is subscription-safe;
+ * API/multi-key deployments raise it with GOV_HARD_MAX.
+ */
+export const HARD_MAX = num(process.env.GOV_HARD_MAX, 4);
+/**
+ * Slots the governor holds back from self-directed (backlog/cadence) work so a
+ * human/agent reply always has subscription + host headroom to GENERATE, not
+ * merely a dispatch slot. The dispatcher's RESERVED_INBOX_SLOTS reserves a
+ * dispatch slot; this reserves the scarce resource that actually timed out.
+ */
+export const REACTIVE_RESERVE = num(process.env.GOV_REACTIVE_RESERVE, 2);
+/**
+ * The thin trickle of self-directed work a DEGRADED/unfunded seat still runs.
+ * Owner instruction (2026-08-25): throttle backlog on an unfunded seat, do not
+ * stop it — autonomous progress keeps ticking in idle gaps while the inbox lane
+ * gets near-all capacity.
+ */
+export const DEGRADED_BACKLOG_MAX = num(process.env.GOV_DEGRADED_BACKLOG_MAX, 1);
 /** Minimum dynamicMax (always allow at least one session). */
 const MIN_MAX = 1;
 
@@ -348,15 +383,36 @@ export function admit(req = {}, deps) {
   if (mode === "suspended" && (source === "backlog" || source === "cadence")) {
     return decide(DEFER, "budget suspended (>=125% of the seat envelope): deferring non-inbox work");
   }
-  if (mode === "degraded" && source === "backlog") {
-    return decide(DEFER, "budget degraded (>=100% of the seat envelope): self-directed backlog work stopped; obligations + inbox continue");
+  // NOTE: `degraded` (>=100% / unfunded) no longer hard-stops backlog. Owner
+  // instruction (2026-08-25): THROTTLE, don't stop — the seat keeps a thin
+  // trickle of self-directed work so autonomous progress never fully halts,
+  // while the inbox lane gets near-all capacity. Enforced as a lowered
+  // per-source concurrency ceiling immediately below, not a DEFER.
+
+  // (1) Concurrency ceiling → QUEUE (work re-derivable from the queue). The
+  //     ceiling is PER SOURCE, because a dispatch slot is not the scarce
+  //     resource — the single Max subscription + host CPU are. Reactive work
+  //     (inbox / a direct human or agent reply) may use the WHOLE envelope;
+  //     self-directed backlog is held REACTIVE_RESERVE slots short so a reply
+  //     can always be GENERATED (10 parallel sessions once starved the
+  //     quick-reply's claude call into a 60s timeout). A DEGRADED/unfunded seat
+  //     throttles backlog to DEGRADED_BACKLOG_MAX — a trickle in idle gaps.
+  let sourceCeiling;
+  if (humanReply) {
+    sourceCeiling = effectiveMax;
+  } else if (mode === "degraded" && source === "backlog") {
+    sourceCeiling = Math.min(effectiveMax, DEGRADED_BACKLOG_MAX);
+  } else {
+    sourceCeiling = Math.max(1, effectiveMax - REACTIVE_RESERVE);
   }
-
-  // (1) Concurrency ceiling → QUEUE (work re-derivable from the queue).
-  if (liveCount >= effectiveMax) {
-    const why = throttleCeiling < dMax
-      ? `at throttled ceiling (${liveCount}/${effectiveMax}; soft-throttle active)`
-      : `at concurrency ceiling (${liveCount}/${effectiveMax})`;
+  if (liveCount >= sourceCeiling) {
+    const why = mode === "degraded" && source === "backlog"
+      ? `budget degraded: self-directed backlog throttled to ${sourceCeiling} (${liveCount} live; inbox unaffected)`
+      : throttleCeiling < dMax
+        ? `at throttled ceiling (${liveCount}/${sourceCeiling}; soft-throttle active)`
+        : source === "inbox"
+          ? `at concurrency ceiling (${liveCount}/${sourceCeiling})`
+          : `self-directed work yields ${REACTIVE_RESERVE} slots to the inbox (${liveCount}/${sourceCeiling})`;
     return decide(QUEUE, why);
   }
 

package/lib/resource-governor.test.mjs

@@ -68,14 +68,16 @@ function deps(over = {}) {
 // ---------------------------------------------------------------------------
 
 test("dynamicMax sizes by RAM, clamped to min(HARD_MAX, cpus)", () => {
-  // 8GB: floor(8*0.6/0.75) = floor(6.4) = 6, capped by cpus too.
-  assert.equal(dynamicMax({ totalmem: 8 * GB, cpus: 8 }), 6);
-  // 16GB: floor(16*0.6/0.75)=12 → clamp to min(10, cpus). cpus=8 → 8.
-  assert.equal(dynamicMax({ totalmem: 16 * GB, cpus: 8 }), 8);
-  // 16GB with 16 cpus → min(10,16)=10, byRam=12 → clamp to 10.
-  assert.equal(dynamicMax({ totalmem: 16 * GB, cpus: 16 }), 10);
-  // 32GB with 16 cpus: byRam=floor(32*0.6/0.75)=25 → clamp to min(10,16)=10.
-  assert.equal(dynamicMax({ totalmem: 32 * GB, cpus: 16 }), 10);
+  // HARD_MAX is 4 (subscription-safe): the single Max subscription, not host RAM,
+  // is the binding constraint, so anything with a few GB clamps to 4.
+  // 4GB: byRam=floor(4*0.6/0.75)=3 → RAM-bound, below HARD_MAX → 3.
+  assert.equal(dynamicMax({ totalmem: 4 * GB, cpus: 8 }), 3);
+  // 8GB: byRam=floor(8*0.6/0.75)=6 → clamp to min(4,8)=4 → HARD_MAX-bound.
+  assert.equal(dynamicMax({ totalmem: 8 * GB, cpus: 8 }), 4);
+  // 16GB with 16 cpus: byRam=12 → clamp to min(4,16)=4.
+  assert.equal(dynamicMax({ totalmem: 16 * GB, cpus: 16 }), 4);
+  // cpu-bound below HARD_MAX: 16GB with 2 cpus → min(4,2)=2.
+  assert.equal(dynamicMax({ totalmem: 16 * GB, cpus: 2 }), 2);
   // Tiny box always yields at least 1.
   assert.equal(dynamicMax({ totalmem: 1 * GB, cpus: 1 }), 1);
 });
@@ -91,8 +93,8 @@ test("dynamicMax never returns 0 even on a starved box", () => {
 test("admit: healthy box with spare capacity → ADMIT", () => {
   const r = admit({ source: "backlog" }, deps());
   assert.equal(r.decision, DECISIONS.ADMIT);
-  assert.equal(r.snapshot.dynamicMax, 8);
-  assert.equal(r.snapshot.effectiveMax, 8);
+  assert.equal(r.snapshot.dynamicMax, 4);
+  assert.equal(r.snapshot.effectiveMax, 4);
 });
 
 test("admit: inbox on a healthy box → ADMIT", () => {
@@ -104,9 +106,23 @@ test("admit: inbox on a healthy box → ADMIT", () => {
 // QUEUE — concurrency ceiling
 // ---------------------------------------------------------------------------
 
-test("admit: at the concurrency ceiling → QUEUE", () => {
-  // effectiveMax = 8; 8 already live → QUEUE.
-  const r = admit({ source: "backlog" }, deps({ liveClaude: { count: 8, rssMB: 2000 } }));
+test("admit: backlog stops REACTIVE_RESERVE slots short of the ceiling → QUEUE", () => {
+  // effectiveMax = 4; self-directed backlog may use effectiveMax - REACTIVE_RESERVE(2)
+  // = 2. With 2 already live, backlog QUEUEs — holding 2 slots for the inbox so a
+  // reply can always be GENERATED (subscription + host headroom, not just a slot).
+  const r = admit({ source: "backlog" }, deps({ liveClaude: { count: 2, rssMB: 500 } }));
+  assert.equal(r.decision, DECISIONS.QUEUE);
+  assert.match(r.reason, /yields 2 slots to the inbox/);
+});
+
+test("admit: inbox may use the whole envelope; the reactive reserve is for it", () => {
+  // 2 live (backlog's reserved cap) but INBOX still ADMITs — the reserve is its.
+  assert.equal(
+    admit({ source: "inbox" }, deps({ liveClaude: { count: 2, rssMB: 500 } })).decision,
+    DECISIONS.ADMIT,
+  );
+  // Only at the full envelope (effectiveMax=4 live) does even the inbox QUEUE.
+  const r = admit({ source: "inbox" }, deps({ liveClaude: { count: 4, rssMB: 1000 } }));
   assert.equal(r.decision, DECISIONS.QUEUE);
   assert.match(r.reason, /concurrency ceiling/);
 });
@@ -125,9 +141,10 @@ test("admit: throttle ceiling clamps effectiveMax below dynamicMax → QUEUE ear
 
 test("admit: projected RSS over the RAM fraction → QUEUE", () => {
   // 16GB → RAM fraction cap = 16*0.6*1024 ≈ 9830MB. Live RSS 9500MB + 750 > cap.
-  // Keep count below ceiling and memory/load healthy so RSS is the trigger.
+  // Keep count below the reserved backlog ceiling (2) so concurrency passes and
+  // RSS is the trigger.
   const r = admit({ source: "backlog" }, deps({
-    liveClaude: { count: 2, rssMB: 9500 },
+    liveClaude: { count: 1, rssMB: 9500 },
     freemem: 16 * GB * 0.5,
   }));
   assert.equal(r.decision, DECISIONS.QUEUE);
@@ -287,9 +304,19 @@ test("admit reads a real throttle.json from agentRoot and clamps", async () => {
 // the budget ladder (banded against the seat's hq-funded envelope)
 // ---------------------------------------------------------------------------
 
-test("degraded (>=100%): self-directed backlog stops, obligations + inbox continue", () => {
-  assert.equal(admit({ source: "backlog", mode: "degraded" }, deps()).decision, "DEFER");
-  assert.match(admit({ source: "backlog", mode: "degraded" }, deps()).reason, /self-directed backlog work stopped/);
+test("degraded (>=100%): self-directed backlog is THROTTLED (not stopped), obligations + inbox continue", () => {
+  // Owner instruction (2026-08-25): throttle, don't stop. A degraded/unfunded seat
+  // runs DEGRADED_BACKLOG_MAX(1) backlog in idle gaps — with the box idle it ADMITs
+  // one so autonomous progress keeps ticking...
+  assert.equal(
+    admit({ source: "backlog", mode: "degraded" }, deps({ liveClaude: { count: 0, rssMB: 0 } })).decision,
+    "ADMIT",
+  );
+  // ...but with anything already live it QUEUEs — a trickle, never a flood.
+  const r = admit({ source: "backlog", mode: "degraded" }, deps({ liveClaude: { count: 1, rssMB: 300 } }));
+  assert.equal(r.decision, "QUEUE");
+  assert.match(r.reason, /throttled/);
+  // An obligation is not discretionary — it degrades, it does not stop.
   assert.equal(admit({ source: "cadence", mode: "degraded" }, deps()).decision, "ADMIT",
     "an obligation is not discretionary — it degrades, it does not stop");
   assert.equal(admit({ source: "inbox", mode: "degraded" }, deps()).decision, "ADMIT");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.11.3",
+  "version": "2.11.5",
   "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/daemon/classifier.mjs

@@ -384,7 +384,7 @@ function formatItemPrompt(item) {
 
 // ── Parse LLM response into classification object ───────────────────────────
 
-function parseClassification(text) {
+export function parseClassification(text) {
   // Strip markdown code fences if present
   const cleaned = text.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim();
   let parsed;
@@ -408,13 +408,24 @@ function parseClassification(text) {
   const validModels = ["opus", "sonnet"];
   const validCategories = ["action_required", "fyi", "ignore"];
 
+  const directedAtAgent = typeof parsed.directed_at_agent === "boolean" ? parsed.directed_at_agent : false;
+  let priority = validPriorities.includes(parsed.priority) ? parsed.priority : "normal";
+  // A message the classifier is confident is directed AT this agent (a DM or an
+  // @mention) is inherently latency-sensitive — a human or a peer agent is
+  // waiting on the reply. Floor it at "high" so the dispatcher's priority lane
+  // PREEMPTS self-directed backlog for it (dispatcher.isPriorityInbox gates on
+  // critical|high). Without this, a peer agent's routine question classified
+  // "normal" would queue behind a wall of the seat's own backlog and read as "no
+  // reply". Never downgrade critical; never touch an "ignore".
+  if (directedAtAgent && priority === "normal") priority = "high";
+
   return {
-    priority: validPriorities.includes(parsed.priority) ? parsed.priority : "normal",
+    priority,
     action: validActions.includes(parsed.action) ? parsed.action : "queue",
     model: validModels.includes(parsed.model) ? parsed.model : "sonnet",
     summary: typeof parsed.summary === "string" ? parsed.summary : "Unclassified message",
     category: validCategories.includes(parsed.category) ? parsed.category : "fyi",
-    directed_at_agent: typeof parsed.directed_at_agent === "boolean" ? parsed.directed_at_agent : false, // default false — don't respond unless we're confident the message is for this agent
+    directed_at_agent: directedAtAgent, // default false — don't respond unless we're confident the message is for this agent
     // A directly-answerable question gets a quick reply instead of a session +
     // holding ack (see responder.isQuickReply). Default false — when the field
     // is absent or non-boolean, take the session path, never guess "answerable".

package/scripts/daemon/classifier.test.mjs

@@ -245,3 +245,22 @@ test("reaction kind short-circuits before any LLM tier (no fetch)", async () =>
   assert.equal(out.action, "archive");
   assert.equal(out.directed_at_agent, false);
 });
+
+test("parseClassification floors a directed-at-agent message at 'high' so it preempts backlog", () => {
+  // A directed DM/mention is latency-sensitive — someone (human OR peer agent)
+  // is waiting. Bumping normal→high lets dispatcher.isPriorityInbox PREEMPT
+  // self-directed backlog for it, so a peer's routine question isn't starved.
+  const directedNormal = classifier.parseClassification(
+    '{"priority":"normal","action":"respond","model":"sonnet","summary":"peer asks for status","category":"action_required","directed_at_agent":true,"answerable":false}'
+  );
+  assert.equal(directedNormal.priority, "high");
+  assert.equal(directedNormal.directed_at_agent, true);
+
+  // Ambient (not directed) work stays normal — no preemption for the firehose.
+  const ambient = classifier.parseClassification('{"priority":"normal","action":"archive","directed_at_agent":false}');
+  assert.equal(ambient.priority, "normal");
+
+  // Critical is never downgraded, and an "ignore" is never escalated.
+  assert.equal(classifier.parseClassification('{"priority":"critical","directed_at_agent":true}').priority, "critical");
+  assert.equal(classifier.parseClassification('{"priority":"ignore","directed_at_agent":true}').priority, "ignore");
+});

package/scripts/daemon/responder.mjs

@@ -55,6 +55,7 @@ import { rungById } from "../../lib/execution/route.mjs";
 // put an exact string in front of a human with no model in the loop, which is
 // the property the acknowledgement path needed and did not have.
 import { deliver, deliverWithRetry, resolveSlackChannel } from "./deliver.mjs";
+import { startTyping, stopTyping } from "./typing-registry.mjs";
 // The acknowledgement is now COMPOSED, not generated. See assurance.mjs for why
 // (in short: a 60s `claude --print` spawn to write "let me look into it" lost
 // its own race 2 times in 3, and lost it silently).
@@ -855,6 +856,11 @@ export async function sendQuickResponse(item, classResult, routed = null) {
     : null;
 
   try {
+    // Show "is composing…" on the DM the instant we start generating. The quick
+    // path used to be silent — a human saw nothing until the reply landed, or
+    // (under load, when generation timed out) nothing at all. Best-effort;
+    // cleared in the finally so "composing" never outlives the turn.
+    startTyping(item);
     const text = await _generateResponse(item, classResult);
 
     // Validate before sending — block replies that violate critical rules
@@ -951,6 +957,8 @@ export async function sendQuickResponse(item, classResult, routed = null) {
     console.error(`[responder] Quick response failed for ${item.sender}:`, err.message);
     logResponse({ type: "quick_response_error", sender: item.sender, error: err.message });
     return { sent: false, text: null, error: err.message };
+  } finally {
+    try { stopTyping(item); } catch { /* never throw from teardown */ }
   }
 }
 

package/scripts/daemon/typing-registry.mjs

@@ -114,7 +114,15 @@ export function startTyping(item) {
     if (!adapter) return null;
     const source = sourceFromItem(item);
     if (!source || !source.chatId) return null;
-    return adapter.startTypingHeartbeat(source);
+    const key = adapter.startTypingHeartbeat(source);
+    // Observability: a silent indicator was exactly the bug — "is it even
+    // firing?" was unanswerable from the logs. Emit one line when a heartbeat
+    // actually starts (startTypingHeartbeat is idempotent, so this is ~once per
+    // turn, not per beat).
+    if (key) {
+      try { console.log(`[typing] composing… ${service}:${source.chatId}${source.userScope === "dm" ? " (dm)" : ""}`); } catch { /* never throw from logging */ }
+    }
+    return key;
   } catch {
     return null;
   }