charness 0.0.0-stage → 3.1.0

package/dist/pendingQuestionRepost.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @description Pure decision for keeping a pending interactive question at the
+ * BOTTOM of its topic (plan `2026-06-09-question-ux.md`, scope S3). While a
+ * question waits for an answer it must be the last message in the topic; if any
+ * OTHER output reaches the topic (a still-streaming sub-agent, a tool status, an
+ * api-retry notice) the question gets pushed up and the user can't see it.
+ *
+ * The bot owns the I/O (delete the old question message, re-send the current
+ * one, the debounce timer); this module only answers "should we re-post now?"
+ * so the loop-guard logic is unit-testable without a live Telegram round-trip.
+ */
+/**
+ * @description Inputs to {@link checkShouldRepostPendingQuestion}.
+ */
+export interface RepostDecisionInput {
+    /** Whether a question is currently pending for the thread. */
+    isQuestionPending: boolean;
+    /**
+     * Whether the MOST RECENT thing the bot sent to the thread was the question
+     * message itself (vs some other output that landed below it). True right
+     * after the question is posted; flipped false as soon as anything else is
+     * sent. The loop guard: a re-post must never fire in response to its own send.
+     */
+    wasLastSendTheQuestion: boolean;
+    /**
+     * Whether a question post (`postPendingQuestionAt`) is currently IN FLIGHT —
+     * its send has started but `messageId` has not been stored yet. A re-post
+     * must never run concurrently: it would read the PREVIOUS question's
+     * `messageId`, delete that (already-answered) message, and leave the
+     * in-flight post orphaned as a stale duplicate (live race 2026-06-10 in the
+     * test topic: the answered-Q1 "✅" confirmation vanished and Q2 appeared
+     * twice — the plan's named "repost must not fight post-next-question" risk).
+     * The in-flight post lands at the bottom anyway, so skipping loses nothing.
+     */
+    isQuestionPostInFlight: boolean;
+}
+/**
+ * @description Decide whether the pending question should be re-posted to the
+ * bottom. Only when a question is pending AND something other than the question
+ * was the last thing sent AND no question post is currently in flight —
+ * otherwise re-posting would be pointless (no pending question), loop
+ * (re-posting in reaction to its own send), or race the in-flight post over
+ * `messageId` (deleting the wrong message; see
+ * {@link RepostDecisionInput.isQuestionPostInFlight}).
+ */
+export declare function checkShouldRepostPendingQuestion(input: RepostDecisionInput): boolean;
+//# sourceMappingURL=pendingQuestionRepost.d.ts.map

package/dist/pendingQuestionRepost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingQuestionRepost.d.ts","sourceRoot":"","sources":["../src/pendingQuestionRepost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC;;;;;;;;;OASG;IACH,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAMpF"}

package/dist/pendingQuestionRepost.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * @description Pure decision for keeping a pending interactive question at the
+ * BOTTOM of its topic (plan `2026-06-09-question-ux.md`, scope S3). While a
+ * question waits for an answer it must be the last message in the topic; if any
+ * OTHER output reaches the topic (a still-streaming sub-agent, a tool status, an
+ * api-retry notice) the question gets pushed up and the user can't see it.
+ *
+ * The bot owns the I/O (delete the old question message, re-send the current
+ * one, the debounce timer); this module only answers "should we re-post now?"
+ * so the loop-guard logic is unit-testable without a live Telegram round-trip.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkShouldRepostPendingQuestion = checkShouldRepostPendingQuestion;
+/**
+ * @description Decide whether the pending question should be re-posted to the
+ * bottom. Only when a question is pending AND something other than the question
+ * was the last thing sent AND no question post is currently in flight —
+ * otherwise re-posting would be pointless (no pending question), loop
+ * (re-posting in reaction to its own send), or race the in-flight post over
+ * `messageId` (deleting the wrong message; see
+ * {@link RepostDecisionInput.isQuestionPostInFlight}).
+ */
+function checkShouldRepostPendingQuestion(input) {
+    return (input.isQuestionPending &&
+        !input.wasLastSendTheQuestion &&
+        !input.isQuestionPostInFlight);
+}
+//# sourceMappingURL=pendingQuestionRepost.js.map

package/dist/pendingQuestionRepost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingQuestionRepost.js","sourceRoot":"","sources":["../src/pendingQuestionRepost.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAqCH,4EAMC;AAfD;;;;;;;;GAQG;AACH,SAAgB,gCAAgC,CAAC,KAA0B;IACzE,OAAO,CACL,KAAK,CAAC,iBAAiB;QACvB,CAAC,KAAK,CAAC,sBAAsB;QAC7B,CAAC,KAAK,CAAC,sBAAsB,CAC9B,CAAC;AACJ,CAAC"}

package/dist/pinnedStatus.d.ts

@@ -0,0 +1,52 @@
+import type { BindingData } from './state';
+/**
+ * @description Inputs for {@link formatPinnedStatus}.
+ *
+ * Kept as a plain data record (no `SessionKey`, no adapter references) so the
+ * formatter is a pure function and can be unit-tested without booting any
+ * Telegraf / tmux machinery. The bot's `updatePinnedStatus` helper does the
+ * impure plumbing (probing the adapter, reading state, calling Telegram).
+ *
+ * Plan §11 Этап 7 (polish) / §20.5 — pinned per-thread status banner of
+ * the form `📁 <subdir> · <agent> · <state>`.
+ */
+export interface PinnedStatusInputs {
+    /** The persistent binding row for this thread. */
+    binding: BindingData;
+    /**
+     * Adapter display label (e.g. `"Claude Code"`). `null` means no adapter
+     * has been chosen yet for this thread — the banner shows `"no agent"`.
+     */
+    agentLabel: string | null;
+    /**
+     * Currently selected model id (e.g. `"sonnet"` or
+     * `"anthropic/claude-3-5-sonnet"`). Optional — many threads run on the
+     * adapter default and never call `/model`.
+     */
+    model: string | null;
+    /**
+     * Currently selected reasoning-effort level (e.g. `"high"`, `"xhigh"`).
+     * Optional — shown right after the model when set, omitted otherwise.
+     */
+    effort?: string | null;
+    /** True if the adapter reports an active session right now. */
+    isActive: boolean;
+}
+/**
+ * @description Compose the one-line pinned status text for a thread.
+ *
+ * Layout (dot-separated, single line so the Telegram pin stays compact):
+ *
+ *   📁 <subdir> · <agentLabel|no agent> [· <model>] · <state>
+ *
+ * The state segment is mutually exclusive: a closed topic always shows
+ * `🔒 closed` and suppresses the running/idle dot — once the topic is
+ * closed the agent can't run anyway, and the banner is the user's only
+ * pointer to that fact.
+ *
+ * Output is plain text (no Markdown). The pinned banner is permanent UI,
+ * not assistant output, so Telegram's MarkdownV2 parsing hazards are not
+ * worth the formatting noise.
+ */
+export declare function formatPinnedStatus(inputs: PinnedStatusInputs): string;
+//# sourceMappingURL=pinnedStatus.d.ts.map

package/dist/pinnedStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinnedStatus.d.ts","sourceRoot":"","sources":["../src/pinnedStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,kDAAkD;IAClD,OAAO,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;OAIG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,+DAA+D;IAC/D,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAerE"}

package/dist/pinnedStatus.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPinnedStatus = formatPinnedStatus;
+/**
+ * @description Compose the one-line pinned status text for a thread.
+ *
+ * Layout (dot-separated, single line so the Telegram pin stays compact):
+ *
+ *   📁 <subdir> · <agentLabel|no agent> [· <model>] · <state>
+ *
+ * The state segment is mutually exclusive: a closed topic always shows
+ * `🔒 closed` and suppresses the running/idle dot — once the topic is
+ * closed the agent can't run anyway, and the banner is the user's only
+ * pointer to that fact.
+ *
+ * Output is plain text (no Markdown). The pinned banner is permanent UI,
+ * not assistant output, so Telegram's MarkdownV2 parsing hazards are not
+ * worth the formatting noise.
+ */
+function formatPinnedStatus(inputs) {
+    const parts = [];
+    parts.push(`📁 ${inputs.binding.subdir}`);
+    parts.push(inputs.agentLabel ?? 'no agent');
+    if (inputs.model)
+        parts.push(inputs.model);
+    if (inputs.effort)
+        parts.push(`⚙️ ${inputs.effort}`);
+    if (inputs.binding.closed) {
+        parts.push('🔒 closed');
+    }
+    else {
+        parts.push(inputs.isActive ? '🟢 running' : '⚪ idle');
+    }
+    return parts.join(' · ');
+}
+//# sourceMappingURL=pinnedStatus.js.map

package/dist/pinnedStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinnedStatus.js","sourceRoot":"","sources":["../src/pinnedStatus.ts"],"names":[],"mappings":";;AAoDA,gDAeC;AA/BD;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,kBAAkB,CAAC,MAA0B;IAC3D,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,KAAK,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1C,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,UAAU,CAAC,CAAC;IAC5C,IAAI,MAAM,CAAC,KAAK;QAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3C,IAAI,MAAM,CAAC,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAErD,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAC1B,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC1B,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3B,CAAC"}

package/dist/platform/answerSink.d.ts

@@ -0,0 +1,93 @@
+import { type PlatformId, type SessionKey } from '../sessionKey';
+import type { RequestAlertReason, RequestAnswerKind, RequestOrigin, UnreleasedRequestAlert } from '../requests/types';
+/**
+ * @description The core-side contract for delivering an agent's answer to a
+ * request back to the surface the request came from (request/answer core S3).
+ * Each platform registers ONE sink; the core picks it by the conversation key's
+ * `platform` and never branches on a platform itself. It is separate from
+ * `ConnectorOutbound` on purpose: the stream (`deliver`) is fire-and-forget,
+ * while an answer must report whether it landed — a failed answer leaves the
+ * request untouched so the agent can retry.
+ */
+/**
+ * @name RequestAnswerDelivery
+ * @description One answer to deliver. `origin` is the request's own (its
+ * connector-owned attributes say where on the platform to deliver); a request
+ * that is no longer open (`isRequestOpen: false`) is still delivered.
+ */
+export interface RequestAnswerDelivery {
+    requestId: string;
+    kind: RequestAnswerKind;
+    body: string;
+    origin: RequestOrigin;
+    isRequestOpen: boolean;
+}
+/**
+ * @name AnswerDeliveryResult
+ * @description `warning` reports a partial success the agent should know about
+ * but must NOT retry (the answer itself landed).
+ */
+export type AnswerDeliveryResult = {
+    ok: true;
+    warning?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * @name RequestAlertDelivery
+ * @description The alert raised when the wake-up rules give up on an open
+ * request: "something went technically wrong", addressed to a person.
+ */
+export interface RequestAlertDelivery {
+    requestId: string;
+    reason: RequestAlertReason;
+    origin: RequestOrigin;
+}
+/**
+ * @name AlertDeliveryResult
+ * @description `alertRef` is the sink's own handle on what it posted, kept with
+ * the request and handed back to {@link AnswerSink.releaseAlert} when it closes.
+ */
+export type AlertDeliveryResult = {
+    ok: true;
+    alertRef?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** @description A platform's answer and alert delivery. */
+export interface AnswerSink {
+    deliverAnswer(key: SessionKey, delivery: RequestAnswerDelivery): Promise<AnswerDeliveryResult>;
+    deliverAlert(key: SessionKey, alert: RequestAlertDelivery): Promise<AlertDeliveryResult>;
+    /** Undo what keeps an alert prominent (Telegram: unpin it) once its request closed. */
+    releaseAlert(key: SessionKey, alertRef: string): Promise<void>;
+}
+/** @description The sinks of the platforms this process serves. */
+export type AnswerSinks = ReadonlyMap<PlatformId, AnswerSink>;
+/**
+ * @name AnswerSinkLookup
+ * @description The conversation's sink, or why there is none.
+ */
+export type AnswerSinkLookup = {
+    ok: true;
+    sink: AnswerSink;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * @description The sink of a conversation's platform — the ONE lookup every
+ * answer, alert and alert release goes through, so a platform this process does
+ * not serve is reported the same way everywhere.
+ */
+export declare function getAnswerSink(answerSinks: AnswerSinks, key: SessionKey): AnswerSinkLookup;
+/**
+ * @description Release an alert a closed request held (Telegram: unpin it),
+ * through its platform's sink. The request ledger calls it for every close and
+ * again at boot for every alert still unreleased. Rejects when this process
+ * cannot release it (its platform is not served here), so the ledger keeps the
+ * alert for a later start that can.
+ */
+export declare function releaseRequestAlert(answerSinks: AnswerSinks, alert: UnreleasedRequestAlert): Promise<void>;
+//# sourceMappingURL=answerSink.d.ts.map

package/dist/platform/answerSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answerSink.d.ts","sourceRoot":"","sources":["../../src/platform/answerSink.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEtH;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,aAAa,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,aAAa,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG,2DAA2D;AAC3D,MAAM,WAAW,UAAU;IACzB,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC/F,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzF,uFAAuF;IACvF,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAED,mEAAmE;AACnE,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,UAAU,GAAG,gBAAgB,CAGzF;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhH"}

package/dist/platform/answerSink.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnswerSink = getAnswerSink;
+exports.releaseRequestAlert = releaseRequestAlert;
+const sessionKey_1 = require("../sessionKey");
+/**
+ * @description The sink of a conversation's platform — the ONE lookup every
+ * answer, alert and alert release goes through, so a platform this process does
+ * not serve is reported the same way everywhere.
+ */
+function getAnswerSink(answerSinks, key) {
+    const sink = answerSinks.get(key.platform);
+    return sink ? { ok: true, sink } : { ok: false, error: `no answer sink serves platform "${key.platform}"` };
+}
+/**
+ * @description Release an alert a closed request held (Telegram: unpin it),
+ * through its platform's sink. The request ledger calls it for every close and
+ * again at boot for every alert still unreleased. Rejects when this process
+ * cannot release it (its platform is not served here), so the ledger keeps the
+ * alert for a later start that can.
+ */
+async function releaseRequestAlert(answerSinks, alert) {
+    const key = (0, sessionKey_1.tryKeyFromString)(alert.conversationKey);
+    if (!key)
+        throw new Error(`no answer sink serves ${alert.conversationKey}`);
+    const lookup = getAnswerSink(answerSinks, key);
+    if (!lookup.ok)
+        throw new Error(lookup.error);
+    await lookup.sink.releaseAlert(key, alert.alertRef);
+}
+//# sourceMappingURL=answerSink.js.map

package/dist/platform/answerSink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"answerSink.js","sourceRoot":"","sources":["../../src/platform/answerSink.ts"],"names":[],"mappings":";;AA0EA,sCAGC;AASD,kDAMC;AA5FD,8CAAmF;AAqEnF;;;;GAIG;AACH,SAAgB,aAAa,CAAC,WAAwB,EAAE,GAAe;IACrE,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC3C,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,mCAAmC,GAAG,CAAC,QAAQ,GAAG,EAAE,CAAC;AAC9G,CAAC;AAED;;;;;;GAMG;AACI,KAAK,UAAU,mBAAmB,CAAC,WAAwB,EAAE,KAA6B;IAC/F,MAAM,GAAG,GAAG,IAAA,6BAAgB,EAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACpD,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,CAAC,eAAe,EAAE,CAAC,CAAC;IAC5E,MAAM,MAAM,GAAG,aAAa,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IAC/C,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9C,MAAM,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC"}

package/dist/platform/capabilityFallback.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @description How outbound content degrades when the surface cannot express
+ * all of it.
+ *
+ * The core writes what it MEANS — "here are three choices, keep this visible" —
+ * without knowing whether the far side has tappable buttons or a pin. This
+ * module is the single place that reconciles the two, so every connector
+ * degrades identically and no connector has to remember to check.
+ *
+ * The contract that makes degradation lossless: {@link OutboundContent.text}
+ * ALWAYS enumerates the options itself, and {@link OutboundContent.options} is
+ * purely the "offer these as tappable controls too" request. Dropping the
+ * options therefore costs the user the tap, never the information — they answer
+ * by typing the index instead, which is exactly the tracker case.
+ */
+import type { ConnectorCapabilities, OutboundContent } from './outbound';
+/**
+ * @description Reduce `content` to what `capabilities` can actually express.
+ *
+ * Returns the SAME object when nothing has to change, so the all-capable
+ * surface (Telegram) pays nothing and a test asserting identity can prove the
+ * rich path was taken untouched.
+ *
+ * - no `tappableOptions` → the options are dropped; the enumerated list in
+ *   `text` is what the user reads and answers by index.
+ * - no `pinMessages` → `keepVisible` is cleared; the message is still sent, it
+ *   just does not stay prominent.
+ */
+export declare function getDegradedContent(content: OutboundContent, capabilities: ConnectorCapabilities): OutboundContent;
+/**
+ * @description Does this content still need a message of its own after
+ * degradation?
+ *
+ * A surface that can neither pin nor offer controls turns a "prominent" message
+ * back into ordinary content — there is nothing left that distinguishes it, so
+ * forcing a separate message would only fragment the conversation.
+ */
+export declare function checkNeedsOwnMessage(content: OutboundContent): boolean;
+//# sourceMappingURL=capabilityFallback.d.ts.map

package/dist/platform/capabilityFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityFallback.d.ts","sourceRoot":"","sources":["../../src/platform/capabilityFallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEzE;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,qBAAqB,GAClC,eAAe,CASjB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAEtE"}

package/dist/platform/capabilityFallback.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @description How outbound content degrades when the surface cannot express
+ * all of it.
+ *
+ * The core writes what it MEANS — "here are three choices, keep this visible" —
+ * without knowing whether the far side has tappable buttons or a pin. This
+ * module is the single place that reconciles the two, so every connector
+ * degrades identically and no connector has to remember to check.
+ *
+ * The contract that makes degradation lossless: {@link OutboundContent.text}
+ * ALWAYS enumerates the options itself, and {@link OutboundContent.options} is
+ * purely the "offer these as tappable controls too" request. Dropping the
+ * options therefore costs the user the tap, never the information — they answer
+ * by typing the index instead, which is exactly the tracker case.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDegradedContent = getDegradedContent;
+exports.checkNeedsOwnMessage = checkNeedsOwnMessage;
+/**
+ * @description Reduce `content` to what `capabilities` can actually express.
+ *
+ * Returns the SAME object when nothing has to change, so the all-capable
+ * surface (Telegram) pays nothing and a test asserting identity can prove the
+ * rich path was taken untouched.
+ *
+ * - no `tappableOptions` → the options are dropped; the enumerated list in
+ *   `text` is what the user reads and answers by index.
+ * - no `pinMessages` → `keepVisible` is cleared; the message is still sent, it
+ *   just does not stay prominent.
+ */
+function getDegradedContent(content, capabilities) {
+    const shouldDropOptions = !capabilities.tappableOptions && content.options !== undefined;
+    const shouldDropKeepVisible = !capabilities.pinMessages && content.keepVisible === true;
+    if (!shouldDropOptions && !shouldDropKeepVisible)
+        return content;
+    const degraded = { ...content };
+    if (shouldDropOptions)
+        delete degraded.options;
+    if (shouldDropKeepVisible)
+        degraded.keepVisible = false;
+    return degraded;
+}
+/**
+ * @description Does this content still need a message of its own after
+ * degradation?
+ *
+ * A surface that can neither pin nor offer controls turns a "prominent" message
+ * back into ordinary content — there is nothing left that distinguishes it, so
+ * forcing a separate message would only fragment the conversation.
+ */
+function checkNeedsOwnMessage(content) {
+    return content.keepVisible === true || (content.options?.length ?? 0) > 0;
+}
+//# sourceMappingURL=capabilityFallback.js.map

package/dist/platform/capabilityFallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilityFallback.js","sourceRoot":"","sources":["../../src/platform/capabilityFallback.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAgBH,gDAYC;AAUD,oDAEC;AApCD;;;;;;;;;;;GAWG;AACH,SAAgB,kBAAkB,CAChC,OAAwB,EACxB,YAAmC;IAEnC,MAAM,iBAAiB,GAAG,CAAC,YAAY,CAAC,eAAe,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC;IACzF,MAAM,qBAAqB,GAAG,CAAC,YAAY,CAAC,WAAW,IAAI,OAAO,CAAC,WAAW,KAAK,IAAI,CAAC;IACxF,IAAI,CAAC,iBAAiB,IAAI,CAAC,qBAAqB;QAAE,OAAO,OAAO,CAAC;IAEjE,MAAM,QAAQ,GAAoB,EAAE,GAAG,OAAO,EAAE,CAAC;IACjD,IAAI,iBAAiB;QAAE,OAAO,QAAQ,CAAC,OAAO,CAAC;IAC/C,IAAI,qBAAqB;QAAE,QAAQ,CAAC,WAAW,GAAG,KAAK,CAAC;IACxD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,oBAAoB,CAAC,OAAwB;IAC3D,OAAO,OAAO,CAAC,WAAW,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAC5E,CAAC"}

package/dist/platform/commandRouter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @description The platform-neutral command router.
+ *
+ * Command dispatch used to be fused to Telegram: every handler was registered
+ * through `bot.command(...)`, and each one re-parsed its own arguments out of
+ * `ctx.message.text` with an ad-hoc `split(' ').slice(1)`. Neither survives a
+ * second surface — a tracker comment (`@ai-dev please review`) carries the same
+ * intent with none of Telegram's syntax.
+ *
+ * So the split is: the CONNECTOR recognises its own trigger syntax and produces
+ * an {@link InboundCommand}; the CORE owns the name → handler table and the
+ * dispatch. Adding a surface adds a recogniser, not a second command table.
+ */
+import type { InboundCommand, InboundEvent } from './inbound';
+/**
+ * @description A registered command handler. Runs for its own side effects; the
+ * router does not interpret a return value, so declining is not a handler's
+ * choice — a name is either bound or it is not.
+ */
+export type CommandHandler = (event: InboundEvent, command: InboundCommand) => Promise<void> | void;
+export interface CommandRouter {
+    /**
+     * Bind one or more names to `handler`. Matching is EXACT, including case:
+     * Telegram's own command matching is case-sensitive (`/STATUS` is not
+     * `/status`), so folding case here would start answering commands that used
+     * to fall through to the plain-text path. A surface whose commands really are
+     * case-insensitive normalises the name in its own recogniser, where that fact
+     * belongs.
+     */
+    register(names: string | string[], handler: CommandHandler): void;
+    /** Is any handler bound to this name? Used to decide fall-through. */
+    checkIsRegistered(name: string): boolean;
+    /**
+     * Run the handler bound to `event.command`. Resolves `false` when the event
+     * carries no command or no handler is bound — the caller then treats the
+     * message as plain text, exactly as before.
+     */
+    dispatch(event: InboundEvent): Promise<boolean>;
+}
+export declare function createCommandRouter(): CommandRouter;
+/**
+ * @description Split the remainder of a command line into the two argument
+ * shapes handlers actually need.
+ *
+ * Shared by every connector's recogniser so "what counts as an argument" is
+ * decided once. `argsText` keeps the user's inner spacing verbatim (a session
+ * title or a schedule description must survive intact); `args` is the
+ * convenience split for the flag-style commands.
+ */
+export declare function splitCommandArgs(remainder: string): Pick<InboundCommand, 'args' | 'argsText'>;
+//# sourceMappingURL=commandRouter.d.ts.map

package/dist/platform/commandRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandRouter.d.ts","sourceRoot":"","sources":["../../src/platform/commandRouter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9D;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEpG,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IAClE,sEAAsE;IACtE,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACzC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjD;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CAuBnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU,CAAC,CAG7F"}

package/dist/platform/commandRouter.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * @description The platform-neutral command router.
+ *
+ * Command dispatch used to be fused to Telegram: every handler was registered
+ * through `bot.command(...)`, and each one re-parsed its own arguments out of
+ * `ctx.message.text` with an ad-hoc `split(' ').slice(1)`. Neither survives a
+ * second surface — a tracker comment (`@ai-dev please review`) carries the same
+ * intent with none of Telegram's syntax.
+ *
+ * So the split is: the CONNECTOR recognises its own trigger syntax and produces
+ * an {@link InboundCommand}; the CORE owns the name → handler table and the
+ * dispatch. Adding a surface adds a recogniser, not a second command table.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandRouter = createCommandRouter;
+exports.splitCommandArgs = splitCommandArgs;
+function createCommandRouter() {
+    const handlers = new Map();
+    function register(names, handler) {
+        for (const name of Array.isArray(names) ? names : [names]) {
+            handlers.set(name, handler);
+        }
+    }
+    function checkIsRegistered(name) {
+        return handlers.has(name);
+    }
+    async function dispatch(event) {
+        const command = event.command;
+        if (!command)
+            return false;
+        const handler = handlers.get(command.name);
+        if (!handler)
+            return false;
+        await handler(event, command);
+        return true;
+    }
+    return { register, checkIsRegistered, dispatch };
+}
+/**
+ * @description Split the remainder of a command line into the two argument
+ * shapes handlers actually need.
+ *
+ * Shared by every connector's recogniser so "what counts as an argument" is
+ * decided once. `argsText` keeps the user's inner spacing verbatim (a session
+ * title or a schedule description must survive intact); `args` is the
+ * convenience split for the flag-style commands.
+ */
+function splitCommandArgs(remainder) {
+    const argsText = remainder.trim();
+    return { argsText, args: argsText.split(/\s+/).filter(Boolean) };
+}
+//# sourceMappingURL=commandRouter.js.map

package/dist/platform/commandRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandRouter.js","sourceRoot":"","sources":["../../src/platform/commandRouter.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AA+BH,kDAuBC;AAWD,4CAGC;AArCD,SAAgB,mBAAmB;IACjC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA0B,CAAC;IAEnD,SAAS,QAAQ,CAAC,KAAwB,EAAE,OAAuB;QACjE,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1D,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,SAAS,iBAAiB,CAAC,IAAY;QACrC,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED,KAAK,UAAU,QAAQ,CAAC,KAAmB;QACzC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC9B,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAC3B,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAC3B,MAAM,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC;AACnD,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,gBAAgB,CAAC,SAAiB;IAChD,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAClC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;AACnE,CAAC"}

package/dist/platform/connectorSet.d.ts

@@ -0,0 +1,39 @@
+import type { PlatformId, SessionKey } from '../sessionKey';
+/**
+ * @description Which surfaces an instance serves (`CONNECTORS`, Jira connector
+ * plan J3) and the ONE filter every scan of conversations goes through (J3b,
+ * R10). A neutral module: the CLI preflight reads it to guard a start, the bot
+ * to branch its boot — neither imports the other.
+ */
+export declare const connectorIds: readonly ["telegram", "jira"];
+export type ConnectorId = (typeof connectorIds)[number];
+/** An unset `CONNECTORS` keeps the instance what it always was. */
+export declare const defaultConnectors: readonly ConnectorId[];
+export type ConnectorsParse = {
+    ok: true;
+    connectors: ConnectorId[];
+} | {
+    ok: false;
+    error: string;
+};
+/** @description `CONNECTORS` as a comma list (`telegram`, `jira`), unset → Telegram only. */
+export declare function parseConnectors(raw: string | undefined): ConnectorsParse;
+/** @description The platforms whose conversations an instance serving `connectors` owns. */
+export declare function getServedPlatforms(connectors: readonly ConnectorId[]): ReadonlySet<PlatformId>;
+/**
+ * @description Does the conversation belong to one of `platforms`? The one rule
+ * behind {@link getServedConversations}, for a boot scan that walks a persisted
+ * map by serialized key rather than a list of entries.
+ */
+export declare function checkIsServedConversation(key: SessionKey, platforms: ReadonlySet<PlatformId>): boolean;
+/**
+ * @description Only the entries (tmux sessions found at boot, bindings, …) whose
+ * conversation belongs to one of `platforms`. Every boot scan adopts, resumes or
+ * KILLS what it is given, so it first keeps what this instance serves: a Telegram
+ * instance never touches a Jira conversation's session, nor a Jira instance a
+ * Telegram one (the J1 review note).
+ */
+export declare function getServedConversations<T extends {
+    key: SessionKey;
+}>(entries: readonly T[], platforms: ReadonlySet<PlatformId>): T[];
+//# sourceMappingURL=connectorSet.d.ts.map

package/dist/platform/connectorSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectorSet.d.ts","sourceRoot":"","sources":["../../src/platform/connectorSet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE5D;;;;;GAKG;AAEH,eAAO,MAAM,YAAY,+BAAgC,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,EAAE,SAAS,WAAW,EAAiB,CAAC;AAMtE,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,WAAW,EAAE,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAErG,6FAA6F;AAC7F,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe,CASxE;AAED,4FAA4F;AAC5F,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,CAAC,UAAU,CAAC,CAE9F;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,OAAO,CAEtG;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS;IAAE,GAAG,EAAE,UAAU,CAAA;CAAE,EAClE,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,SAAS,EAAE,WAAW,CAAC,UAAU,CAAC,GACjC,CAAC,EAAE,CAEL"}

package/dist/platform/connectorSet.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConnectors = exports.connectorIds = void 0;
+exports.parseConnectors = parseConnectors;
+exports.getServedPlatforms = getServedPlatforms;
+exports.checkIsServedConversation = checkIsServedConversation;
+exports.getServedConversations = getServedConversations;
+/**
+ * @description Which surfaces an instance serves (`CONNECTORS`, Jira connector
+ * plan J3) and the ONE filter every scan of conversations goes through (J3b,
+ * R10). A neutral module: the CLI preflight reads it to guard a start, the bot
+ * to branch its boot — neither imports the other.
+ */
+exports.connectorIds = ['telegram', 'jira'];
+/** An unset `CONNECTORS` keeps the instance what it always was. */
+exports.defaultConnectors = ['telegram'];
+function checkIsConnectorId(name) {
+    return exports.connectorIds.some((id) => id === name);
+}
+/** @description `CONNECTORS` as a comma list (`telegram`, `jira`), unset → Telegram only. */
+function parseConnectors(raw) {
+    if (raw === undefined || raw.trim() === '')
+        return { ok: true, connectors: [...exports.defaultConnectors] };
+    const names = raw.split(',').map((name) => name.trim()).filter((name) => name !== '');
+    const unknown = names.filter((name) => !checkIsConnectorId(name));
+    if (unknown.length > 0) {
+        return { ok: false, error: `CONNECTORS has unknown connector(s) ${unknown.join(', ')} (known: ${exports.connectorIds.join(', ')})` };
+    }
+    if (names.length === 0)
+        return { ok: false, error: 'CONNECTORS names no connector' };
+    return { ok: true, connectors: exports.connectorIds.filter((id) => names.includes(id)) };
+}
+/** @description The platforms whose conversations an instance serving `connectors` owns. */
+function getServedPlatforms(connectors) {
+    return new Set(connectors);
+}
+/**
+ * @description Does the conversation belong to one of `platforms`? The one rule
+ * behind {@link getServedConversations}, for a boot scan that walks a persisted
+ * map by serialized key rather than a list of entries.
+ */
+function checkIsServedConversation(key, platforms) {
+    return platforms.has(key.platform);
+}
+/**
+ * @description Only the entries (tmux sessions found at boot, bindings, …) whose
+ * conversation belongs to one of `platforms`. Every boot scan adopts, resumes or
+ * KILLS what it is given, so it first keeps what this instance serves: a Telegram
+ * instance never touches a Jira conversation's session, nor a Jira instance a
+ * Telegram one (the J1 review note).
+ */
+function getServedConversations(entries, platforms) {
+    return entries.filter(({ key }) => checkIsServedConversation(key, platforms));
+}
+//# sourceMappingURL=connectorSet.js.map

package/dist/platform/connectorSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectorSet.js","sourceRoot":"","sources":["../../src/platform/connectorSet.ts"],"names":[],"mappings":";;;AAsBA,0CASC;AAGD,gDAEC;AAOD,8DAEC;AASD,wDAKC;AAzDD;;;;;GAKG;AAEU,QAAA,YAAY,GAAG,CAAC,UAAU,EAAE,MAAM,CAAU,CAAC;AAG1D,mEAAmE;AACtD,QAAA,iBAAiB,GAA2B,CAAC,UAAU,CAAC,CAAC;AAEtE,SAAS,kBAAkB,CAAC,IAAY;IACtC,OAAO,oBAAY,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC;AAChD,CAAC;AAID,6FAA6F;AAC7F,SAAgB,eAAe,CAAC,GAAuB;IACrD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,GAAG,yBAAiB,CAAC,EAAE,CAAC;IACpG,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;IACtF,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC;IAClE,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,uCAAuC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,oBAAY,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IAC/H,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,+BAA+B,EAAE,CAAC;IACrF,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,oBAAY,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;AACnF,CAAC;AAED,4FAA4F;AAC5F,SAAgB,kBAAkB,CAAC,UAAkC;IACnE,OAAO,IAAI,GAAG,CAAa,UAAU,CAAC,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,SAAgB,yBAAyB,CAAC,GAAe,EAAE,SAAkC;IAC3F,OAAO,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,sBAAsB,CACpC,OAAqB,EACrB,SAAkC;IAElC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,yBAAyB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;AAChF,CAAC"}