@cohortapp/agent-sdk 2.11.2 → 2.11.4

package/archetypes/capabilities/executive-operator.yaml

@@ -38,7 +38,11 @@ skills:
 workflows:
   - { id: weekly-operating-review, name: "Weekly operating review", cadence: weekly, purpose: "Run the leadership operating cadence: surface on-track/at-risk OKRs, blockers and decisions needed, then publish the review" }
   - { id: commitment-sweep, name: "Commitment closure sweep", cadence: daily, purpose: "Sweep open action items and commitments, chase ageing/overdue owners, and keep the register clean" }
-  - { id: inbox-to-outcome, name: "Inbox-to-outcome triage", cadence: continuous, purpose: "Convert the principal's inbox and inbound channels into routed actions, decisions and tracked commitments" }
+  # inbox-to-outcome (cadence: continuous) removed 2026-08-25: it generated a
+  # continuous cadence + plist expecting schedules/triggers/inbox-to-outcome.md,
+  # which does not exist, so it span skipped_circuit_open forever and padded the
+  # queue. Real inbox triage is already covered by the STANDARD_CADENCES
+  # inbox-processor + messaging-inbound (both have prompts). No replacement needed.
   - { id: board-cadence, name: "Board and investor cadence", cadence: quarterly, purpose: "Drive the board meeting cycle end to end — pre-reads, pack, decisions-sought and post-meeting action closure" }
   - { id: quarterly-planning, name: "Quarterly planning and OKRs", cadence: quarterly, purpose: "Open and run the planning cycle: refresh strategy, set objectives, cascade owners and lock roadmap traceability" }
   - { id: leadership-meeting-cycle, name: "Leadership meeting cycle", cadence: weekly, purpose: "Architect, pre-read, capture and follow up the recurring leadership-team and exec-staff meetings" }

package/lib/plan/compile.mjs

@@ -344,6 +344,15 @@ export function compilePlan(input = {}) {
   for (const c of archetypeCadences) {
     if (!c || !c.id) continue;
     if (c.scope === "standard") continue; // already emitted verbatim above
+    // A `cadence: continuous` capability (inbox triage, SLA/obligation watch) is
+    // a standing REAL-TIME responsibility, NOT a launchd tick. It ships no
+    // schedules/triggers/<id>.md, so compiling it to a SCHEDULE fires every
+    // interval, finds no prompt, and spins `skipped_circuit_open` forever,
+    // padding the cadence-bus queue on every seat. Do NOT schedule it; the
+    // daemon's real-time loop owns the capability. The legacy producer
+    // (scripts/setup/generate-cadences.mjs) applies the SAME skip, so the two
+    // stay byte-identical (mandate.test.mjs COMPATIBILITY).
+    if (c.cadence === "continuous") continue;
     const key = `schedule.${c.id}`;
     if (obligations.some((o) => o.key === key)) continue;
     const uses = resolveUses(usesForArchetypeCadence(c, reachable), key);

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.2",
+  "version": "2.11.4",
   "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;
   }

package/scripts/setup/generate-cadences.mjs

@@ -59,7 +59,15 @@ async function main() {
   // resolveArchetype validates the pair; throws if invalid.
   await resolveArchetype(sel);
 
-  const cadences = await resolveCadences(sel);
+  // A `cadence: continuous` capability (inbox triage, SLA/obligation watch) is a
+  // standing REAL-TIME responsibility, NOT a launchd tick: it ships no
+  // schedules/triggers/<id>.md, so scheduling it fires every interval, finds no
+  // prompt, and spins `skipped_circuit_open` forever, padding the cadence-bus
+  // queue. Drop it here so it never becomes a cadence/registry/plist entry; the
+  // daemon's real-time loop owns the capability. The plan compiler
+  // (lib/plan/compile.mjs §2) applies the SAME skip, so the two producers stay
+  // byte-identical (mandate.test.mjs COMPATIBILITY).
+  const cadences = (await resolveCadences(sel)).filter((c) => c.cadence !== "continuous");
 
   mkdirSync(join(AGENT_ROOT, "config"), { recursive: true });
   writeFileSync(join(AGENT_ROOT, "config", "cadences.yaml"),