@cohortapp/agent-sdk 2.15.0 → 2.17.0

package/lib/assurance/tier.test.mjs

@@ -0,0 +1,174 @@
+/**
+ * tier.test.mjs — the reply tier, across the whole classifier matrix.
+ *
+ * The tier is the ONE decision that says whether a human hears anything before
+ * the answer. Getting it wrong in the loud direction is the 3,069 generic acks
+ * and 961 clock-derived nags measured in production on 2026-09-12; getting it
+ * wrong in the quiet direction is the silence the obligation ledger was built
+ * to end. So every cell of the matrix is pinned here rather than sampled.
+ *
+ * Run: node --test lib/assurance/tier.test.mjs
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  replyTier,
+  TIERS,
+  ANSWER_MAX_RUNG,
+  PLAN_MIN_RUNG,
+  PLAN_ACTIONS,
+  PLAN_PRIORITIES,
+} from "./tier.mjs";
+
+/** Every value `classifier.mjs` can emit — the real enums, not a sample. */
+const ACTIONS = ["respond", "draft", "research", "queue", "archive", "ignore"];
+const PRIORITIES = ["critical", "high", "normal", "ignore"];
+/** Every rung in `lib/execution/route.RUNGS`, plus "not routed yet". */
+const RUNGS = [0, 1, 2, 3, 4, 5, null];
+
+describe("replyTier — the three tiers and nothing else", () => {
+  test("every cell of the matrix returns one of exactly three tiers", () => {
+    for (const action of ACTIONS) {
+      for (const priority of PRIORITIES) {
+        for (const rung of RUNGS) {
+          for (const answerable of [true, false, null, undefined]) {
+            for (const willSpawnSession of [true, false]) {
+              const t = replyTier({ answerable, action, priority, rung, willSpawnSession });
+              assert.ok(TIERS.includes(t), `{${action}/${priority}/rung:${rung}/answerable:${answerable}/spawn:${willSpawnSession}} → ${t}`);
+            }
+          }
+        }
+      }
+    }
+  });
+
+  test("no session spawning ⇒ answer tier, whatever the classifier said", () => {
+    // The reply arrives in this turn. An interim in front of an answer the
+    // human is about to read is the definition of content-free traffic.
+    for (const action of ACTIONS) {
+      for (const priority of PRIORITIES) {
+        for (const rung of RUNGS) {
+          assert.equal(
+            replyTier({ answerable: false, action, priority, rung, willSpawnSession: false }),
+            "answer",
+            `${action}/${priority}/rung:${rung} with no session must be "answer"`,
+          );
+        }
+      }
+    }
+  });
+
+  test("answerable at rung 0 or 1 is the answer tier — the reply IS the acknowledgement", () => {
+    // `willSpawnSession` UNKNOWN: the caller is asking hypothetically (which is
+    // how WP-2's effort router will use it), so the classifier verdict decides.
+    for (const rung of [0, ANSWER_MAX_RUNG]) {
+      assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung }), "answer");
+      assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung, willSpawnSession: false }), "answer");
+    }
+  });
+
+  test("REGRESSION: an ASSERTED session disqualifies the answer tier, however answerable the item looked", () => {
+    // THE QUICK-PATH FALL-THROUGH. agent-daemon.mjs tries a quick reply first;
+    // when that reply fails transiently or is blocked by validation it falls
+    // THROUGH to a full session dispatch and asks for a tier with
+    // willSpawnSession:true while classResult.answerable is still true. The
+    // answer tier's whole premise — "the reply arrives in this turn" — is
+    // exactly what the fall-through has falsified.
+    //
+    // Latent rather than live only because `rung` is null today (R13). The
+    // moment WP-2 routes it, that item would have landed in `answer`,
+    // shouldAcknowledge would have returned ack:false, the sweep would have
+    // read the durable tier as never-speak, and a 15-45 minute session would
+    // have run with the human hearing NOTHING at all. Pinned before WP-2 lands
+    // on top of it.
+    for (const rung of [0, ANSWER_MAX_RUNG]) {
+      assert.equal(
+        replyTier({ answerable: true, action: "respond", priority: "high", rung, willSpawnSession: true }),
+        "work",
+        `rung ${rung}: a spawning session speaks once at most — it is never silent`,
+      );
+    }
+    // …and the plan tier still outranks it, because rung 3+ is a project.
+    assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung: 4, willSpawnSession: true }), "plan");
+  });
+
+  test("a routed rung of 3 or above is the plan tier, whatever the action", () => {
+    for (const rung of RUNGS.filter((r) => r != null && r >= PLAN_MIN_RUNG)) {
+      for (const action of ACTIONS) {
+        assert.equal(
+          replyTier({ answerable: false, action, priority: "normal", rung, willSpawnSession: true }),
+          "plan",
+          `rung ${rung} / ${action} must be "plan"`,
+        );
+      }
+    }
+  });
+
+  test("research or draft at critical/high priority is the plan tier even with no routed rung", () => {
+    for (const action of PLAN_ACTIONS) {
+      for (const priority of PLAN_PRIORITIES) {
+        assert.equal(replyTier({ answerable: false, action, priority, rung: null, willSpawnSession: true }), "plan");
+      }
+    }
+  });
+
+  test("…and the same actions at normal priority are only work", () => {
+    for (const action of PLAN_ACTIONS) {
+      for (const priority of ["normal", "ignore"]) {
+        assert.equal(replyTier({ answerable: false, action, priority, rung: null, willSpawnSession: true }), "work");
+      }
+    }
+  });
+
+  test("the ordinary directed ask — respond/high, unrouted — is work: silence, then at most one line", () => {
+    // This is the shape of the overwhelming majority of the 10,667 measured
+    // agent messages. It must NOT be plan tier, or the flood returns wearing a
+    // better costume.
+    assert.equal(replyTier({ answerable: false, action: "respond", priority: "high", rung: null, willSpawnSession: true }), "work");
+    assert.equal(replyTier({ answerable: false, action: "queue", priority: "critical", rung: null, willSpawnSession: true }), "work");
+  });
+
+  test("an ABSENT rung is never read as the cheapest rung", () => {
+    // `lib/backlog` already learned this: absence is not rung 0. A missing rung
+    // may not buy the answer tier's silence-on-the-strength-of-a-quick-path,
+    // and may not buy the plan tier's licence to speak either.
+    assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung: null, willSpawnSession: true }), "work");
+    assert.equal(replyTier({ answerable: true, action: "respond", priority: "high", rung: undefined, willSpawnSession: true }), "work");
+  });
+
+  test("a non-numeric or out-of-range rung is treated as unrouted, never as a licence to speak", () => {
+    for (const rung of ["3", "team", NaN, Infinity, -1, 6, {}, []]) {
+      assert.equal(
+        replyTier({ answerable: false, action: "respond", priority: "normal", rung, willSpawnSession: true }),
+        "work",
+        `rung ${JSON.stringify(rung)} must not be trusted`,
+      );
+    }
+  });
+
+  test("answerable only counts when it is strictly true", () => {
+    // classifier.mjs coerces a missing/odd field to false for the same reason:
+    // never guess "answerable".
+    for (const answerable of ["true", 1, {}, null, undefined]) {
+      assert.equal(replyTier({ answerable, action: "respond", priority: "high", rung: 0, willSpawnSession: true }), "work");
+    }
+  });
+
+  test("garbage in gives work out — the tier never throws and never invents silence", () => {
+    // Fail-open direction: the tier that can still speak, never the tier that
+    // cannot. A classifier failure must not silently mute the agent.
+    assert.equal(replyTier(), "work");
+    assert.equal(replyTier(null), "work");
+    assert.equal(replyTier({}), "work");
+    assert.equal(replyTier({ action: 12, priority: [], rung: "x", willSpawnSession: "yes" }), "work");
+  });
+
+  test("the tier is a pure function — same input, same answer, no ambient reads", () => {
+    const args = { answerable: false, action: "research", priority: "critical", rung: null, willSpawnSession: true };
+    const first = replyTier(args);
+    for (let i = 0; i < 50; i++) assert.equal(replyTier(args), first);
+    assert.deepEqual(args, { answerable: false, action: "research", priority: "critical", rung: null, willSpawnSession: true }, "the argument is not mutated");
+  });
+});

package/lib/comms/receipts.mjs

@@ -211,12 +211,28 @@ export function spokeSince(q = {}) {
  * @param {string} [q.agentRoot]
  * @returns {{heard:boolean, basis:string}}
  */
+/**
+ * Receipt kinds that are COURTESIES, not answers.
+ *
+ * A receipt of one of these proves the agent said something in the room; it
+ * does not prove the ask was answered, and discharging a debt on one closes an
+ * unanswered question as answered.
+ *
+ * `progress` is retained although nothing emits it any more (deleted
+ * 2026-09-12 — see `scripts/daemon/assurance.mjs`): receipts already on disk
+ * carry it, and a historical progress ping must not start discharging debts on
+ * the day it stops being written. `notice` is the interrupted/orphan apology —
+ * information about the MACHINE, not about the ask. `plan` is the plan-tier
+ * interim.
+ */
+export const NON_ANSWER_KINDS = Object.freeze(["ack", "progress", "notice", "failure", "plan"]);
+
 export function spokeFor(q = {}) {
   const rec = q.obligation || {};
   const ch = channelKey(rec.channel);
   const since = Number.isFinite(rec.openedAt) ? rec.openedAt : q.now;
   if (!ch || !Number.isFinite(since)) return { heard: false, basis: "no-channel" };
-  const exclude = Array.isArray(q.excludeKinds) ? q.excludeKinds : ["ack", "progress", "failure"];
+  const exclude = Array.isArray(q.excludeKinds) ? q.excludeKinds : NON_ANSWER_KINDS;
   const recs = readReceiptsSince(since, q).filter(
     (r) => r.channel === ch && !exclude.includes(r.kind),
   );

package/lib/context/budget.mjs

@@ -0,0 +1,327 @@
+/**
+ * lib/context/budget.mjs — the declared token budget for an inbound prompt.
+ *
+ * Every bound in this repo up to now has been a row count or a `.slice(n)` char
+ * clamp (design §5.4, R8). Both are proxies: a row count cannot tell a one-word
+ * turn from a pasted stack trace, and a char clamp spends the allowance on
+ * whichever section happens to be assembled first. So the prompt that reaches
+ * the model is whatever the assembly order happened to produce, and the parts
+ * that fall off do so SILENTLY — the model reads a thread with a hole in it and
+ * cannot tell the hole from a conversation that never happened.
+ *
+ * This module states the budget instead of discovering it:
+ *
+ *   1. a budget PER TIER (§5.1) — an Answer gets 6k input tokens, Work 12k,
+ *      Plan 20k. Context rot is measured: accuracy falls with input length well
+ *      before the window limit, so a bigger prompt is not a better one.
+ *   2. sections filled in PRIORITY order ({@link SECTION_ORDER}) — the trigger
+ *      is the thing being answered and is never dropped whole; the backlog is
+ *      the first thing to go.
+ *   3. every drop VISIBLE — `… 14 earlier turns not shown`, in the prompt, where
+ *      the model reads it. A section that did not fit at all still leaves a line
+ *      saying so.
+ *
+ * PURE. No clock, no env, no fs, no network: tokens are estimated from
+ * character length at {@link CHARS_PER_TOKEN}, the same ratio
+ * `context-compiler.mjs` already uses, so the two agree. A caller that has a
+ * real tokeniser passes `estimate` and this module uses it instead.
+ *
+ * Char clamps stay where they are as a second belt — this is the first one.
+ *
+ * @module lib/context/budget
+ */
+
+"use strict";
+
+/** Characters per token. The estimate `scripts/daemon/context-compiler.mjs` uses. */
+export const CHARS_PER_TOKEN = 4;
+
+/**
+ * Input-token budget per reply tier (design §5.4). A tier is the ack/effort
+ * tier from `lib/assurance/tier.mjs` — answer | work | plan.
+ */
+export const TIER_BUDGETS = Object.freeze({
+  answer: 6000,
+  work: 12000,
+  plan: 20000,
+});
+
+/**
+ * FILL priority. Earlier wins the budget; later is dropped first.
+ *
+ *   trigger  the message being answered — without it there is nothing to answer
+ *   thread   the conversation it sits in
+ *   entity   the anchored artifact: the task card, the doc body, the decision
+ *   digest   the distilled record of this thread
+ *   memory   recalled facts from elsewhere
+ *   backlog  what else is open — useful, never load-bearing
+ */
+export const FILL_PRIORITY = Object.freeze([
+  "trigger",
+  "thread",
+  "entity",
+  "digest",
+  "memory",
+  "backlog",
+]);
+
+/**
+ * RENDER order — a DIFFERENT question, and conflating the two costs the cache.
+ *
+ * Fill priority asks "who wins the budget"; the trigger wins it, because a
+ * prompt without the message being answered is not a smaller prompt but a
+ * broken one. Render order asks "what byte comes first", and design §4 is
+ * explicit about the consequence: "any byte change before a breakpoint
+ * invalidates everything after it". Rendering the trigger first — the ONE
+ * section that is different on every single inbound — gives the block a
+ * zero-length stable prefix, so WP-4's `cache_control` breakpoint would sit
+ * after volatile content and every read would be a silent miss. Prompt caching
+ * is the highest-ROI latency lever in the research pass; this is what it needs.
+ *
+ * So: stable first, volatile last, trigger last of all. `thread` sits second to
+ * last because it is append-only and rendered oldest-first, which makes its own
+ * prefix stable between turns even as it grows.
+ */
+export const RENDER_ORDER = Object.freeze([
+  "entity",
+  "digest",
+  "backlog",
+  "memory",
+  "thread",
+  "trigger",
+]);
+
+/**
+ * @deprecated Read {@link FILL_PRIORITY} or {@link RENDER_ORDER} by name — the
+ * whole point of the split is that "the section order" is two different orders.
+ * Kept as an alias so an existing importer does not silently get the wrong one.
+ */
+export const SECTION_ORDER = FILL_PRIORITY;
+
+/** Sections that must render SOMETHING rather than be dropped whole. */
+const NEVER_DROPPED_WHOLE = new Set(["trigger"]);
+
+/** A blank-safe string. */
+function s(v) {
+  return v == null ? "" : String(v);
+}
+
+/** The declared budget for a tier; an unknown tier takes the middle one. */
+export function budgetFor(tier) {
+  const key = s(tier).toLowerCase();
+  return Object.prototype.hasOwnProperty.call(TIER_BUDGETS, key) ? TIER_BUDGETS[key] : TIER_BUDGETS.work;
+}
+
+/** Estimated tokens for a string, rounded up so a partial token still costs one. */
+export function estimateTokens(text, charsPerToken = CHARS_PER_TOKEN) {
+  const t = s(text);
+  if (!t) return 0;
+  const per = Number.isFinite(charsPerToken) && charsPerToken > 0 ? charsPerToken : CHARS_PER_TOKEN;
+  return Math.ceil(t.length / per);
+}
+
+/** Where a section sorts in a declared order; unknown names sort last, stably. */
+function rankIn(order, name) {
+  const i = order.indexOf(name);
+  return i === -1 ? order.length : i;
+}
+
+/** `1 earlier turn` / `14 earlier turns` — the count is the point, so it leads. */
+function turnNote(n) {
+  return `… ${n} earlier turn${n === 1 ? "" : "s"} not shown`;
+}
+
+/** `… 1,204 characters not shown`. */
+function charNote(n) {
+  return `… ${n.toLocaleString("en-US")} character${n === 1 ? "" : "s"} not shown`;
+}
+
+/**
+ * @typedef {Object} SectionInput
+ * @property {string} name             one of {@link SECTION_ORDER}, or any name (sorts last)
+ * @property {string} [title]          heading rendered above the body
+ * @property {string} [text]           a whole-text section
+ * @property {string[]} [turns]        a turn-structured section, OLDEST FIRST
+ */
+
+/**
+ * @typedef {Object} FittedSection
+ * @property {string} name
+ * @property {boolean} included        false == dropped whole (still rendered as a note)
+ * @property {string} text             what was kept, drop note included
+ * @property {number} keptTurns
+ * @property {number} droppedTurns
+ * @property {number} droppedChars
+ * @property {number} tokens
+ */
+
+/**
+ * Fit the sections into the tier's budget.
+ *
+ * Turn-structured sections spend the budget from the NEWEST turn backwards —
+ * the turns nearest the message being answered are the ones that explain it
+ * (the same rule `lib/org/inbound/hydrate.mjs#renderThread` follows, and for the
+ * same reason: clipping the joined string keeps the oldest turns and drops the
+ * newest, which is the exact inverse of what context is for).
+ *
+ * NEVER THROWS. A malformed section is skipped; a missing budget takes the
+ * tier's. The prompt path must not be able to fail on its own budgeting.
+ *
+ * @param {Object} o
+ * @param {SectionInput[]} o.sections
+ * @param {string} [o.tier]                    answer | work | plan
+ * @param {number} [o.budgetTokens]            override the tier's budget
+ * @param {number} [o.charsPerToken]
+ * @param {(text:string)=>number} [o.estimate] a real tokeniser, when the caller has one
+ * @returns {{tier:string, budgetTokens:number, usedTokens:number,
+ *           sections:FittedSection[], drops:Array<object>, text:string}}
+ */
+export function fitSections(o = {}) {
+  const tier = s(o.tier).toLowerCase() || "work";
+  const budgetTokens = Number.isFinite(o.budgetTokens) && o.budgetTokens > 0
+    ? Math.floor(o.budgetTokens)
+    : budgetFor(tier);
+  const charsPerToken = Number.isFinite(o.charsPerToken) && o.charsPerToken > 0 ? o.charsPerToken : CHARS_PER_TOKEN;
+  const tokensOf = typeof o.estimate === "function" ? o.estimate : (t) => estimateTokens(t, charsPerToken);
+
+  const input = (Array.isArray(o.sections) ? o.sections : [])
+    .map((sec, i) => ({ sec, i }))
+    .filter(({ sec }) => sec && typeof sec === "object" && s(sec.name))
+    .sort((a, b) => rankIn(FILL_PRIORITY, s(a.sec.name)) - rankIn(FILL_PRIORITY, s(b.sec.name)) || a.i - b.i);
+
+  const out = [];
+  const drops = [];
+  let used = 0;
+
+  for (const { sec } of input) {
+    const name = s(sec.name);
+    const title = s(sec.title);
+    const headCost = title ? tokensOf(`${title}\n`) : 0;
+    const room = budgetTokens - used - headCost;
+
+    const fitted = Array.isArray(sec.turns)
+      ? fitTurns(sec.turns, room, tokensOf)
+      : fitText(s(sec.text), room, tokensOf, charsPerToken);
+
+    // A section with no content at all is simply absent — there is nothing to
+    // report the loss of, and a note about an empty section is noise.
+    if (fitted.empty) continue;
+
+    if (!fitted.body && !NEVER_DROPPED_WHOLE.has(name)) {
+      // Dropped whole. It still shows: an absence the reader cannot see is the
+      // failure this module exists to prevent.
+      const note = `… ${name} not shown`;
+      const cost = tokensOf(note);
+      if (used + cost <= budgetTokens) {
+        out.push({ name, included: false, text: note, keptTurns: 0, droppedTurns: fitted.droppedTurns, droppedChars: fitted.droppedChars, tokens: cost });
+        used += cost;
+      } else {
+        out.push({ name, included: false, text: "", keptTurns: 0, droppedTurns: fitted.droppedTurns, droppedChars: fitted.droppedChars, tokens: 0 });
+      }
+      drops.push({ section: name, turns: fitted.droppedTurns, chars: fitted.droppedChars, note });
+      continue;
+    }
+
+    // The trigger is the thing being answered: it always renders something,
+    // even when the budget cannot pay for it. A prompt with no trigger is not a
+    // smaller prompt, it is a broken one.
+    let body = fitted.body;
+    if (!body && NEVER_DROPPED_WHOLE.has(name)) {
+      const minChars = Math.max(1, Math.floor(Math.max(room, 1) * charsPerToken));
+      const whole = Array.isArray(sec.turns) ? sec.turns.filter(Boolean).map(s).join("\n") : s(sec.text);
+      body = whole.slice(0, minChars);
+      const lost = whole.length - body.length;
+      if (lost > 0) {
+        body += `\n${charNote(lost)}`;
+        drops.push({ section: name, turns: 0, chars: lost, note: charNote(lost) });
+      }
+    } else if (fitted.droppedTurns > 0) {
+      drops.push({ section: name, turns: fitted.droppedTurns, chars: 0, note: turnNote(fitted.droppedTurns) });
+    } else if (fitted.droppedChars > 0) {
+      drops.push({ section: name, turns: 0, chars: fitted.droppedChars, note: charNote(fitted.droppedChars) });
+    }
+
+    const text = title ? `${title}\n${body}` : body;
+    const cost = tokensOf(text);
+    out.push({
+      name,
+      included: true,
+      text,
+      keptTurns: fitted.keptTurns,
+      droppedTurns: fitted.droppedTurns,
+      droppedChars: fitted.droppedChars,
+      tokens: cost,
+    });
+    used += cost;
+  }
+
+  // Filled in priority order, RENDERED in cache order. The two are separate
+  // arrays for the reason RENDER_ORDER states, and this is the only place the
+  // difference is applied.
+  const rendered = out
+    .map((sec, i) => ({ sec, i }))
+    .sort((a, b) => rankIn(RENDER_ORDER, a.sec.name) - rankIn(RENDER_ORDER, b.sec.name) || a.i - b.i)
+    .map(({ sec }) => sec);
+
+  return {
+    tier,
+    budgetTokens,
+    usedTokens: used,
+    sections: rendered,
+    drops,
+    text: rendered.map((sec) => sec.text).filter(Boolean).join("\n\n"),
+  };
+}
+
+/** Keep the newest turns that fit; report the rest as a visible note. */
+function fitTurns(turns, room, tokensOf) {
+  const rows = (Array.isArray(turns) ? turns : []).filter((t) => s(t).trim()).map((t) => s(t));
+  if (rows.length === 0) return { empty: true, body: "", keptTurns: 0, droppedTurns: 0, droppedChars: 0 };
+  if (room <= 0) return { empty: false, body: "", keptTurns: 0, droppedTurns: rows.length, droppedChars: 0 };
+
+  const kept = [];
+  let used = 0;
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const cost = tokensOf(rows[i]) + (kept.length ? 1 : 0);
+    // The note itself has to fit, or the drop would be the silent kind.
+    const reserve = i > 0 ? tokensOf(turnNote(i)) + 1 : 0;
+    if (used + cost + reserve > room) break;
+    kept.unshift(rows[i]);
+    used += cost;
+  }
+  const dropped = rows.length - kept.length;
+  if (kept.length === 0) return { empty: false, body: "", keptTurns: 0, droppedTurns: dropped, droppedChars: 0 };
+  const body = dropped > 0 ? [turnNote(dropped), ...kept].join("\n") : kept.join("\n");
+  return { empty: false, body, keptTurns: kept.length, droppedTurns: dropped, droppedChars: 0 };
+}
+
+/** Keep the head that fits; report the tail as a visible note. */
+function fitText(text, room, tokensOf, charsPerToken) {
+  const t = s(text).trim();
+  if (!t) return { empty: true, body: "", keptTurns: 0, droppedTurns: 0, droppedChars: 0 };
+  if (room <= 0) return { empty: false, body: "", keptTurns: 0, droppedTurns: 0, droppedChars: t.length };
+  if (tokensOf(t) <= room) return { empty: false, body: t, keptTurns: 1, droppedTurns: 0, droppedChars: 0 };
+
+  // Reserve room for the note, then take the largest head that still fits.
+  let chars = Math.max(0, Math.floor(room * charsPerToken));
+  let head = t.slice(0, chars);
+  let note = charNote(t.length - head.length);
+  while (head.length > 0 && tokensOf(`${head}\n${note}`) > room) {
+    chars = Math.floor(chars * 0.8);
+    head = t.slice(0, chars);
+    note = charNote(t.length - head.length);
+  }
+  if (!head) return { empty: false, body: "", keptTurns: 0, droppedTurns: 0, droppedChars: t.length };
+  return { empty: false, body: `${head}\n${note}`, keptTurns: 1, droppedTurns: 0, droppedChars: t.length - head.length };
+}
+
+export default {
+  TIER_BUDGETS,
+  FILL_PRIORITY,
+  RENDER_ORDER,
+  SECTION_ORDER,
+  CHARS_PER_TOKEN,
+  budgetFor,
+  estimateTokens,
+  fitSections,
+};