@cohortapp/agent-sdk 2.11.1 → 2.11.3

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cohortapp/agent-sdk",
-  "version": "2.11.1",
+  "version": "2.11.3",
   "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/assurance-e2e.test.mjs

@@ -190,7 +190,8 @@ test("SCENARIO 2 — a slow ask is acknowledged at once, updated while it runs,
   const ack = transcript.find((m) => m.kind === "ack");
   assert.ok(ack, "the acknowledgement must go out");
   assert.ok(ack.ms < 1000, `acknowledged in ${ack.ms}ms — the old path budgeted 60,000ms and missed 2 times in 3`);
-  assert.match(ack.text, /either way/i);
+  assert.match(ack.text, /on it|looking now|digging in/i);
+  assert.ok(ack.text.length <= 40, "the ack is one short human line, not a templated paragraph");
 
   const key = assurance.openObligations()[0].key;
   note("obligation opened and acknowledged; session running");
@@ -248,7 +249,7 @@ test("SCENARIO 3 — a timing-out session tells the human what happened and that
   const failure = transcript.filter((m) => m.kind === "failure").at(-1);
   assert.ok(failure, "the human MUST be told; the old code emitted telemetry and nothing else");
   assert.match(failure.text, /ran past its time limit/i);
-  assert.match(failure.text, /retrying it now/i);
+  assert.match(failure.text, /retrying now/i);
   assert.equal(assurance.readObligation(key).state, "open", "still owed until the retry resolves");
   note("item left un-processed for redelivery; the debt stays open so the retry is covered too", virtual.v);
 });
@@ -278,7 +279,7 @@ test("SCENARIO 4 — a crashing session tells the human it failed, stops, and es
 
   assert.equal(r.willRetry, false, "a spawn failure is permanent — retrying burns another 45 minutes for the same outcome");
   const failure = transcript.filter((m) => m.kind === "failure").at(-1);
-  assert.match(failure.text, /couldn't get this done/i);
+  assert.match(failure.text, /couldn't finish this/i);
   assert.match(failure.text, /stopped retrying/i);
   assert.match(failure.text, /flagged it so it isn't lost/i);
   assert.match(failure.text, /\?\s*$/, "a dead end ends in a question, so the human has a move");

package/scripts/daemon/assurance.mjs

@@ -311,16 +311,13 @@ function variant(seed, n) {
 /**
  * Trim the classifier's summary into a short topic phrase — casing preserved.
  *
- * This used to lowercase the first letter so the phrase could sit mid-sentence.
- * Applied to a summary that starts with an acronym or a name, that manufactures
- * a typo the requester reads as the agent's own: "Picking up: cEO checking in
- * on work progress." went to a real human, first letter of "CEO" folded. No
- * local rule can tell "Fix" (safe to downcase) from "CEO", "Q3" or a person's
- * name (not safe), so the phrase is taken exactly as the classifier wrote it, and
- * every slot that renders it — the parentheses here and in topicAside — is one
- * where original casing reads correctly. The stored `rec.summary` flows into
- * progress/failure/interrupted messages and the board-row title too, so the
- * no-recasing rule protects all of them at once.
+ * This is NO LONGER interpolated into any message a human reads (the "(CEO
+ * asking what machine…)" bleed is gone — see composeAck). It survives only to
+ * populate `rec.summary`, which feeds the board-row title and the
+ * needs-attention escalation record. Casing is preserved because a summary that
+ * starts with an acronym or a name ("CEO", "Q3") must not be mangled in those
+ * records either; no local rule can tell "Fix" (safe to downcase) from "CEO"
+ * (not), so the phrase is stored exactly as the classifier wrote it.
  */
 function topicClause(classResult, item) {
   const raw = (classResult && classResult.summary) || (item && item.subject) || "";
@@ -329,84 +326,49 @@ function topicClause(classResult, item) {
   return t;
 }
 
-/** Rough, honest expectation. Derived from the measured distribution of real
- *  sessions, not invented: sonnet work clusters near a minute, opus work near
- *  fifteen. Phrased as a range because it IS a range. */
-export function expectedWindow(classResult) {
-  const model = classResult && classResult.model;
-  const priority = classResult && classResult.priority;
-  if (model === "opus" || priority === "critical") return "usually within 10-20 minutes";
-  return "usually within a few minutes";
-}
-
 /**
- * The acknowledgement. Two sentences, written the way a colleague would type
- * them, and — critically — it commits to coming back "either way". That clause
- * is a promise the rest of this module now actually keeps: failure notices,
- * interim updates and the stale sweep all exist so it is never a lie. The time
- * window is expectedWindow's — measured, not invented.
- *
- * The topic rides in parentheses at the end of the opener, never spliced into
- * the sentence: the summary is an arbitrary phrase in arbitrary case, and the
- * previous template — `Picking up: <lowercased summary>. It needs a bit of
- * work, …` — showed the daemon's internal framing to the requester and mangled
- * acronym-initial summaries on top (see topicClause). "Picking up:" is triage
- * vocabulary; a human answering a human does not narrate their queue.
+ * The acknowledgement — sent ONLY when genuinely long, multi-step work is about
+ * to run (a directly-answerable question is answered in the turn on the quick
+ * path, never acked). So it is one plain line, the way a colleague types it
+ * before they get to work: no aside, no filler, no promise-of-followup
+ * boilerplate. The failure notices, interim updates and stale sweep are what
+ * actually keep the human informed — the ack does not need to narrate them.
+ *
+ * The classifier's summary is DELIBERATELY not shown here. It used to ride in a
+ * parenthetical aside, which leaked the daemon's internal framing to the
+ * requester verbatim — "(CEO asking what machine/infrastructure is being used)"
+ * reached a real human. The summary is still stored on the obligation for the
+ * board row and escalations; it just never appears in a message a person reads.
  */
-export function composeAck(item, classResult = {}) {
-  const topic = topicClause(classResult, item);
-  const aside = topic ? ` (${topic})` : "";
+export function composeAck(item) {
   const v = variant(obligationKey(item) || (item && item.sender), 3);
-  const openers = [
-    `No problem — I'm looking into this now${aside}.`,
-    `Got it — I'm on it now${aside}.`,
-    `Understood — I'm digging into this now${aside}.`,
-  ];
-  return `${openers[v]} I want to get this right, so I'll come back to you here with a full answer — ${expectedWindow(classResult)} — and you'll hear from me either way.`;
-}
-
-/**
- * The topic, set off in parentheses.
- *
- * It is NOT interpolated as the object of a preposition, because the classifier's
- * summary is as often a verb phrase ("fix the issues and push them") as a noun
- * phrase ("July spend reconciliation") — and "Still working on fix the issues"
- * is the kind of sentence that tells a reader they are talking to a machine.
- * Parentheses read correctly for both.
- */
-function topicAside(rec) {
-  return rec && rec.summary ? ` (${rec.summary})` : "";
+  return ["On it.", "Looking now.", "On it — digging in now."][v];
 }
 
-/** An interim update. Says how long it has been and that the work is live.
- *  The first update no longer claims "it's taking longer than I expected": it
- *  fires at PROGRESS_AFTER_MS (5 min), squarely inside the 10-20 minute window
- *  the acknowledgement promised for opus work minutes earlier — a claim the
- *  same human could see was false. */
+/** An interim update. Says how long it has been and that the work is live —
+ *  short, no internal topic aside, no filler. */
 export function composeProgress(rec, o = {}) {
   const now = Number.isFinite(o.now) ? o.now : Date.now();
   const mins = Math.max(1, Math.round((now - (rec.openedAt || now)) / 60_000));
-  const topic = topicAside(rec);
   if ((rec.progressSent || 0) === 0) {
-    return `Still working on this${topic} — ${mins} minutes in. Nothing's stuck; I'll come back as soon as I have something worth sending.`;
+    return `Still on this — ${mins} minutes in. I'll come back as soon as I've got something.`;
   }
-  return `Quick check-in: still on this${topic}, ${mins} minutes in. I haven't forgotten it — I'll follow up the moment it's done, or tell you if I can't finish it.`;
+  return `Still going — ${mins} minutes in. I'll follow up the moment it's done.`;
 }
 
 /**
  * The failure notice. Says WHAT HAPPENED and WHAT HAPPENS NEXT, in that order,
  * because those are the two things the human is missing when a session dies.
- * Never blames the human, never hides behind "an error occurred", and never
- * ends without a next step.
+ * Terse and human: never blames the human, never hides behind "an error
+ * occurred", never ends without a next step, and never shows internal framing.
  */
 export function composeFailure(rec, o = {}) {
   const f = o.failure || {};
-  const topic = topicAside(rec);
   const cause = f.human || "the working session ended unexpectedly";
   if (o.willRetry) {
-    return `I hit a problem with this${topic} — ${cause}. I'm retrying it now (attempt ${(rec.attempts || 1) + 1} of ${RETRY_MAX + 1}); if it fails again I'll come straight back to you rather than leave you waiting.`;
+    return `Hit a problem — ${cause}. Retrying now; if it fails again I'll come straight back rather than leave you waiting.`;
   }
-  return `I couldn't get this done${topic} — ${cause}. I've stopped retrying so I'm not silently burning time on it, and I've flagged it so it isn't lost. Do you want me to try a narrower version of this, hand it to someone else, or leave it with you?`;
+  return `Couldn't finish this — ${cause}. I've stopped retrying and flagged it so it isn't lost. Want me to try a narrower version, hand it off, or leave it with you?`;
 }
 
 /**
@@ -416,20 +378,18 @@ export function composeFailure(rec, o = {}) {
  * `sent`. This message is what the human gets instead of that silence.
  */
 export function composeSilentSuccess(rec, o = {}) {
-  const topic = topicAside(rec);
   const tail = (o.finalText || "").trim();
-  const head = `I finished working on this${topic} but didn't get a reply out to you — that's my fault, not yours.`;
+  const head = `Finished this but didn't get a reply out to you — my fault.`;
   if (tail) {
     const excerpt = tail.length > 900 ? `${tail.slice(0, 900).trimEnd()}…` : tail;
-    return `${head} Here's where I got to:\n\n${excerpt}\n\nIf that doesn't answer it, say so and I'll take another run at it.`;
+    return `${head} Here's where I got to:\n\n${excerpt}`;
   }
-  return `${head} I don't have a clean result to show you, so I'd rather say that than pretend otherwise. Want me to run it again?`;
+  return `${head} I don't have a clean result to show you, though. Want me to run it again?`;
 }
 
 /** A session interrupted by the daemon itself dying/restarting. */
-export function composeInterrupted(rec) {
-  const topic = topicAside(rec);
-  return `Heads up — my working session on this${topic} was interrupted before it finished (my end restarted). I've put it back in the queue and I'm picking it up again now; I'll come back to you with the answer.`;
+export function composeInterrupted() {
+  return `Heads up — my session on this was interrupted before it finished (my end restarted). I've picked it back up; I'll come back with the answer.`;
 }
 
 // ---------------------------------------------------------------------------

package/scripts/daemon/assurance.test.mjs

@@ -135,28 +135,28 @@ describe("composeAck", () => {
     assert.equal(a, composeAck(ITEM, CLASS_COMPLEX), "same input must give the same words");
   });
 
-  test("names the actual ask and promises to come back either way", () => {
+  test("is one short human line — no filler, no promise-of-followup boilerplate", () => {
     const a = composeAck(ITEM, CLASS_COMPLEX);
-    assert.match(a, /fix the noted issues and push the fixes to git/i);
-    assert.match(a, /either way/i, "the promise the rest of the system exists to keep");
-    assert.match(a, /10-20 minutes/, "an opus/critical item is honestly framed as slow");
+    assert.ok(a.length <= 40, `an ack is one short line, got ${a.length} chars: ${a}`);
+    // The templated filler communication-style.md bans.
+    assert.doesNotMatch(a, /either way|full answer|within a few minutes|within 10-20|I want to get this right|hear from me|come back to you/i);
   });
 
   test("degrades gracefully when the classifier gave nothing to go on", () => {
     const a = composeAck(ITEM, {});
-    assert.ok(a.length > 40);
-    assert.match(a, /either way/i);
+    assert.ok(a.length > 0);
+    assert.doesNotMatch(a, /\(.*\)/, "no parenthetical aside");
   });
 
-  test("REGRESSION: an acronym-initial summary keeps its casing — no 'cEO'", () => {
-    // Owner screenshot, verbatim: "Picking up: cEO checking in on work
-    // progress." — topicClause downcased the first letter of whatever the
-    // classifier wrote so it could sit mid-sentence, and "CEO…" became a typo
-    // the requester reads as the agent's own. The summary is now carried
-    // exactly as written.
-    const a = composeAck(ITEM, { ...CLASS_COMPLEX, summary: "CEO checking in on work progress" });
-    assert.match(a, /CEO checking in on work progress/);
-    assert.doesNotMatch(a, /cEO/);
+  test("REGRESSION: the classifier summary NEVER reaches the human — no '(CEO …)' bleed", () => {
+    // Owner screenshot, verbatim: the ack carried the classifier's internal
+    // summary in a parenthetical aside — "(CEO asking what machine/infrastructure
+    // is being used)" reached a real human. The summary is now stored on the
+    // obligation for the board row but never shown in a message anyone reads.
+    const a = composeAck(ITEM, { ...CLASS_COMPLEX, summary: "CEO asking what machine/infrastructure is being used" });
+    assert.doesNotMatch(a, /CEO asking/i);
+    assert.doesNotMatch(a, /machine\/infrastructure/i);
+    assert.doesNotMatch(a, /\(.*\)/, "no parenthetical aside at all");
   });
 
   test("reads like a colleague, not a template — no internal framing shown to the human", () => {
@@ -223,10 +223,10 @@ describe("openAndAcknowledge", () => {
     assert.equal(openObligations().length, 1, "the debt must be visible to the sweep");
   });
 
-  test("the stored summary keeps the classifier's casing — every later message reads from it", async () => {
-    // `rec.summary` feeds topicAside (progress, failure, silent-success,
-    // interrupted), the sweep's compensating ack, and board-mirror's row title.
-    // A summary mangled at open time would resurface in all of them.
+  test("the stored summary keeps the classifier's casing — the board row and escalations read from it", async () => {
+    // `rec.summary` feeds board-mirror's row title and the needs-attention
+    // escalation record. A summary mangled at open time would resurface there.
+    // It must NOT, however, appear in any message the human reads.
     const t = fakeTransport();
     const r = await openAndAcknowledge({
       item: ITEM,
@@ -235,7 +235,7 @@ describe("openAndAcknowledge", () => {
     });
     const rec = readObligation(r.key);
     assert.equal(rec.summary, "CEO checking in on work progress");
-    assert.match(composeProgress(rec, { now: Date.now() + 6 * 60_000 }), /\(CEO checking in on work progress\)/);
+    assert.doesNotMatch(composeProgress(rec, { now: Date.now() + 6 * 60_000 }), /CEO checking in on work progress/, "the summary is never leaked into a progress update");
   });
 
   test("acknowledges ONCE — a re-delivered item does not re-announce itself", async () => {
@@ -339,7 +339,7 @@ describe("settleSession", () => {
     assert.match(r.verdict, /^retrying:timeout$/);
     const msg = t.sent.at(-1).text;
     assert.match(msg, /ran past its time limit/i);
-    assert.match(msg, /retrying it now/i);
+    assert.match(msg, /retrying now/i);
     assert.equal(readObligation(key).state, "open", "still owed — the retry has to be covered too");
   });
 
@@ -350,7 +350,7 @@ describe("settleSession", () => {
     assert.equal(r.willRetry, false);
     assert.match(r.verdict, /^failed:spawn_failed$/);
     const msg = t.sent.at(-1).text;
-    assert.match(msg, /couldn't get this done/i);
+    assert.match(msg, /couldn't finish this/i);
     assert.match(msg, /stopped retrying/i);
     assert.match(msg, /\?$/, "a dead end must end in a question, not a shrug");
     assert.equal(readObligation(key).state, "failed");
@@ -384,7 +384,7 @@ describe("sweepObligations", () => {
     const now = Date.now() + ACK_GRACE_MS + 1000;
     const stats = await sweepObligations({ now, deps: { deliverImpl: working.impl, spokeSinceImpl: () => false } });
     assert.equal(stats.acked, 1);
-    assert.match(working.sent[0].text, /come back to you/i);
+    assert.match(working.sent[0].text, /on it|looking now|digging in/i);
     assert.equal(readObligation(r.key).acknowledged, true);
   });
 
@@ -395,7 +395,7 @@ describe("sweepObligations", () => {
     const stats = await sweepObligations({ now, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
     assert.equal(stats.progressed, 1);
     const msg = t.sent.at(-1).text;
-    assert.match(msg, /still working/i);
+    assert.match(msg, /still on this/i);
     assert.match(msg, /minutes in/i, "an interim update that omits how long it has been is not much of an update");
     // Six minutes in is INSIDE the 10-20 minute window the ack just promised
     // for opus work; claiming it here contradicts a message the same human read.
@@ -642,7 +642,7 @@ describe("attribution: which debt did that message actually discharge", () => {
     const stats = await sweepObligations({ now: Date.now() + ACK_GRACE_MS + 1000, deps: { deliverImpl: t.impl } });
     assert.equal(stats.closed, 0, "no session of ours had run — that message was not our answer");
     assert.equal(stats.acked, 1, "instead the missing acknowledgement is finally sent");
-    assert.match(t.sent.at(-1).text, /looking into this|on it now|digging into this/i);
+    assert.match(t.sent.at(-1).text, /on it|looking now|digging in/i);
   });
 });
 
@@ -719,7 +719,7 @@ describe("a running retry is not declared dead", () => {
       now: t0 + 45 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false },
     });
     assert.equal(settled.willRetry, true);
-    assert.match(t.sent.at(-1).text, /retrying it now/i);
+    assert.match(t.sent.at(-1).text, /retrying now/i);
 
     const stats = await sweepObligations({ now: t0 + 51 * 60_000, deps: { deliverImpl: t.impl, spokeSinceImpl: () => false } });
     assert.equal(stats.staled, 0, "the retry is minutes old, not fifty");

package/scripts/daemon/classifier.mjs

@@ -243,7 +243,8 @@ Your job: classify each incoming message and return a JSON object with exactly t
   "model": "opus" | "sonnet",
   "summary": "<one-line summary of the message>",
   "category": "action_required" | "fyi" | "ignore",
-  "directed_at_agent": true | false
+  "directed_at_agent": true | false,
+  "answerable": true | false
 }
 ${peerContext}
 Classification rules:
@@ -271,6 +272,10 @@ CATEGORY:
 - "fyi": Informational, no action needed
 - "ignore": No value
 
+ANSWERABLE (can ${agentName} answer this DIRECTLY, in one reply, right now?):
+- true: A question that can be answered from what ${agentName} already knows or can see, needing NO tools, NO external lookups, NO drafting, and NO multi-step work — e.g. "what machine are you running on?", "which model are you?", "are you online?", "what's your role?", a simple factual or conversational question. These get answered immediately instead of a "I'll look into it" holding message, even from the ${principalTitle}.
+- false: Anything that needs an action performed (send, schedule, file, push, draft, research, look something up), anything multi-step, or anything that is not a direct question. When unsure, use false — a wrong direct answer is worse than a brief wait.
+
 DIRECTED_AT_AGENT (CRITICAL — determines whether ${agentName} should respond. Default to false in channels/group chats.):
 - true: The message is a DM to ${agentName} (1:1)
 - true: The message explicitly mentions ${agentName} by name or @mention
@@ -300,43 +305,46 @@ Context:
 Examples:
 
 Input: CEO DM on Slack: "Can you send the board resolution to Jordan?"
-Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO requesting board resolution sent to GC Jordan","category":"action_required","directed_at_agent":true}
+Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO requesting board resolution sent to GC Jordan","category":"action_required","directed_at_agent":true,"answerable":false}
+
+Input: CEO DM on Slack: "what kind of machine are you running on?"
+Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO asking what machine/infrastructure the agent runs on","category":"action_required","directed_at_agent":true,"answerable":true}
 
 Input: GitHub notification email about a merged PR
-Output: {"priority":"ignore","action":"ignore","model":"sonnet","summary":"GitHub PR merge notification","category":"ignore","directed_at_agent":false}
+Output: {"priority":"ignore","action":"ignore","model":"sonnet","summary":"GitHub PR merge notification","category":"ignore","directed_at_agent":false,"answerable":false}
 
 Input: Leadership Slack: "We need the the regulator gap analysis updated by Thursday"
-Output: {"priority":"high","action":"draft","model":"opus","summary":"Leadership requesting the regulator gap analysis update by Thursday deadline","category":"action_required","directed_at_agent":true}
+Output: {"priority":"high","action":"draft","model":"opus","summary":"Leadership requesting the regulator gap analysis update by Thursday deadline","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Team member: "Standup notes from today's sync"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team standup notes shared","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team standup notes shared","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: External email: "Following up on our conversation about the Singapore entity"
-Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"External follow-up on Singapore entity discussion","category":"action_required","directed_at_agent":true}
+Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"External follow-up on Singapore entity discussion","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Channel message from Jacob: "@${agentName} can you check the engine deployment?"
-Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"Jacob asking ${agentName} to check engine deployment","category":"action_required","directed_at_agent":true}
+Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"Jacob asking ${agentName} to check engine deployment","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Channel message from CEO: "@AnotherAgent can you review the agentic libraries in this channel?"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"CEO asking another agent to review agentic libraries — not directed at ${agentName}","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"CEO asking another agent to review agentic libraries — not directed at ${agentName}","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Channel message from Sam to Jordan: "Jordan, did you file the compliance response yet?"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Sam asking Jordan about compliance response filing","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Sam asking Jordan about compliance response filing","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Channel thread — Jacob: "pushed the fix" / Sam: "nice, looks good"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team exchange about code fix","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team exchange about code fix","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Thread where ${agentName} previously replied — Jacob: "yeah that makes sense, I'll handle it" (responding to Sam, not ${agentName})
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jacob acknowledging Sam in thread","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jacob acknowledging Sam in thread","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Thread where ${agentName} previously replied — Sam: "${agentName}, can you send the updated doc?"
-Output: {"priority":"high","action":"respond","model":"sonnet","summary":"Sam asking ${agentName} for updated document","category":"action_required","directed_at_agent":true}
+Output: {"priority":"high","action":"respond","model":"sonnet","summary":"Sam asking ${agentName} for updated document","category":"action_required","directed_at_agent":true,"answerable":false}
 
 Input: Channel message: "FYI — the Cayman entity docs are signed and filed"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"FYI: Cayman entity docs signed and filed","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"FYI: Cayman entity docs signed and filed","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Input: Group chat — Jordan: "Sam, can we sync on the the regulator gaps tomorrow?"
-Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jordan asking Sam to sync on the regulator gaps","category":"fyi","directed_at_agent":false}
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jordan asking Sam to sync on the regulator gaps","category":"fyi","directed_at_agent":false,"answerable":false}
 
 Return ONLY the JSON object. No explanation, no markdown fencing, no extra text.`;
 }
@@ -407,6 +415,10 @@ function parseClassification(text) {
     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
+    // 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".
+    answerable: parsed.answerable === true,
   };
 }
 
@@ -781,5 +793,6 @@ function classifiedAttrs(r) {
     model: r.model,
     category: r.category,
     directed_at_agent: r.directed_at_agent,
+    answerable: r.answerable,
   };
 }

package/scripts/daemon/execution-ladder.test.mjs

@@ -384,6 +384,29 @@ test("RUNG: the quick-reply responder accepts rungs 0-1 and refuses 2+", async (
   );
 });
 
+test("ANSWERABLE: a directly-answerable question is quick-replied, not sessioned + acked", () => {
+  // "what machine are you running on?" from the CEO classifies critical/opus,
+  // which would otherwise force a session and a robotic holding ack. Flagged
+  // answerable, it is answered in the turn instead — the defect being fixed.
+  assert.equal(
+    responder.isQuickReply({ action: "respond", priority: "critical", model: "opus", answerable: true }),
+    true,
+    "an answerable question skips the session even at critical/opus",
+  );
+  // The flag only fast-paths a `respond` — a draft/research item stays on the
+  // session path even if the classifier also (contradictorily) flags it.
+  assert.equal(responder.isQuickReply({ action: "draft", priority: "high", model: "opus", answerable: true }), false);
+  assert.equal(responder.isQuickReply({ action: "research", priority: "normal", model: "sonnet", answerable: true }), false);
+  // And the rung veto still wins over answerable.
+  assert.equal(
+    responder.isQuickReply({ action: "respond", priority: "critical", model: "opus", answerable: true }, { rung: 3 }),
+    false,
+    "a rung-3 answer needs a session even when the classifier called it answerable",
+  );
+  // Without the flag, a critical/opus item still takes the session path.
+  assert.equal(responder.isQuickReply({ action: "respond", priority: "critical", model: "opus" }), false);
+});
+
 // ---------------------------------------------------------------------------
 // 8) REGRESSION (live run): with no need estimate every DM routed to rung 3,
 //    which vetoed the quick reply and spawned a session for a two-line message.

package/scripts/daemon/responder.mjs

@@ -1075,6 +1075,17 @@ export function isQuickReply(classResult, routed = null) {
   // place, or a caller that has no ladder) leaves the original rules untouched.
   if (!rungPermitsQuickReply(routed)) return false;
 
+  // ── directly-answerable question: answer it, don't ack it ────────────────
+  // A factual question the classifier judged answerable in one reply — no
+  // tools, no drafting, no multi-step work ("what machine are you running on?")
+  // — belongs on the quick path even from the CEO and even when the model or
+  // priority would otherwise route it to a session. Spawning a 15-minute
+  // session and posting a robotic "I'm looking into this now (CEO asking…)" to
+  // a question that could be answered in one line IS the defect being fixed.
+  // Gated to `respond` so a `draft`/`research` item that also gets flagged
+  // answerable (a classifier contradiction) still takes the session path.
+  if (classResult.answerable === true && classResult.action === "respond") return true;
+
   // These always need full sessions — never quick reply
   if (classResult.action === "research") return false;
   if (classResult.action === "draft") return false;

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"),