comisai 1.0.45 → 1.0.46

package/node_modules/@comis/core/dist/context-store/parts-codec.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Pure parts <-> pi-ai canonical Message round-trip (F2/F3).
+ * Pure parts <-> pi-ai canonical Message round-trip (lossless fidelity +
+ * reasoning exclusion).
  *
  * Lives in core — the only non-agent package that depends on pi-ai. No
  * embedded database, no wall-clock reads — pure + unit-testable. Provider-
@@ -12,7 +13,7 @@
  * the OpenAI Responses function-output blocks, etc.) here — pi-ai owns that
  * and is version-pinned.
  *
- * Fidelity model (F1/F2): every content block is emitted as one part whose
+ * Fidelity model: every content block is emitted as one part whose
  * `metadata.raw` is the verbatim canonical block; the message-level envelope
  * (every top-level field except `content`) rides verbatim on the FIRST part's
  * `metadata.messageEnvelope`. A top-level `ToolResultMessage` is its own
@@ -21,7 +22,7 @@
  * round-trip drops no field; the typed tool columns are the queryable
  * projection, not the source of truth.
  *
- * F3: a `thinking` block becomes a `reasoning` part marked
+ * Reasoning exclusion: a `thinking` block becomes a `reasoning` part marked
  * `topLevelReasoningOnly` and is NOT re-emitted as a visible content block on
  * reconstruction (excluded from visible content + summarizer input); its tokens
  * were already counted agent-side at write time (`estimateMessageTokens` counts
@@ -41,10 +42,10 @@ function envelopeOf(msg) {
     return { ...rest };
 }
 /**
- * Decompose a canonical pi-ai `Message` into structured LCD parts (write path,
- * F1): one part per content block, plus a single `tool_result` part for a
+ * Decompose a canonical pi-ai `Message` into structured LCD parts (write
+ * path): one part per content block, plus a single `tool_result` part for a
  * top-level `ToolResultMessage`. Captures `metadata.raw` = the verbatim block
- * (or whole tool-result message), the F3 top-level reasoning marker, and the
+ * (or whole tool-result message), the top-level reasoning marker, and the
  * message-level envelope on the first part.
  */
 export function messageToParts(msg) {
@@ -63,11 +64,11 @@ export function messageToParts(msg) {
         }
         return part;
     });
-    // WR-01: an empty-content message (e.g. an aborted/errored assistant turn,
+    // An empty-content message (e.g. an aborted/errored assistant turn,
     // `content: []`) would otherwise emit zero parts, so the `index === 0`
     // envelope-attachment above never runs and the whole envelope
     // (api/provider/model/usage/stopReason/errorMessage/timestamp) is lost on
-    // round-trip — a direct F2 violation. Emit a single envelope-carrier part
+    // round-trip — a direct fidelity violation. Emit a single envelope-carrier part
     // (no `raw` block) so the envelope always has a carrier; `partsToMessage`
     // restores the envelope from it and excludes it from the reconstructed
     // visible content, faithfully rebuilding an empty-content message.
@@ -81,18 +82,18 @@ export function messageToParts(msg) {
 }
 /**
  * Reconstruct a canonical pi-ai `Message` from a persisted `LcdMessage` (read
- * path, F2): rebuild blocks with STABLE ids (so tool_use<->tool_result pair),
+ * path): rebuild blocks with STABLE ids (so tool_use<->tool_result pair),
  * preferring `metadata.raw` for exactness, restore the message envelope from
  * the first part, and exclude `topLevelReasoningOnly` reasoning from the
- * reconstructed VISIBLE content (F3).
+ * reconstructed VISIBLE content.
  */
 export function partsToMessage(row) {
     if (row.role === "toolResult") {
         return toolResultFromPart(row);
     }
     // user | assistant: restore the envelope from the first part, then rebuild
-    // the visible content blocks (F3: skip topLevelReasoningOnly reasoning;
-    // WR-01: skip an envelope-carrier placeholder — it holds the envelope of an
+    // the visible content blocks (skip topLevelReasoningOnly reasoning;
+    // skip an envelope-carrier placeholder — it holds the envelope of an
     // empty-content message, not a real block, so it must not become content).
     const envelope = (row.parts[0]?.metadata.messageEnvelope ?? {});
     const content = row.parts
@@ -109,11 +110,11 @@ function blockToPart(block) {
         case "text":
             return { kind: "text", metadata: { raw: block, rawType: "text" } };
         case "image":
-            // F1: the verbatim ImageContent (data + mimeType) is kept in metadata.raw;
-            // no externalization in Phase 127.
+            // The verbatim ImageContent (data + mimeType) is kept in metadata.raw;
+            // the codec never externalizes image bytes.
             return { kind: "file", metadata: { raw: block, rawType: "image" } };
         case "thinking":
-            // F3: reasoning is captured as a marked part, excluded from visible
+            // Reasoning is captured as a marked part, excluded from visible
             // content on reconstruction, but its tokens are counted at write time.
             return {
                 kind: "reasoning",
@@ -146,8 +147,7 @@ function blockFromPart(part) {
     // NEVER become a content block: a sparse block crashes every downstream
     // `.type` consumer (token estimator, transcript-repair) inside the LCD
     // assembler's transformContext — BEFORE the LLM call — aborting the whole turn
-    // and surfacing to the user as a silent "AI didn't produce a response"
-    // (LCD-codec regression 2026-06-14: openai-codex on a fresh install).
+    // and surfacing to the user as a silent "AI didn't produce a response".
     const raw = part.metadata.raw;
     if (raw != null && typeof raw === "object" && typeof raw.type === "string") {
         return raw;

package/node_modules/@comis/core/dist/delivery/chunk-for-delivery.d.ts

@@ -29,8 +29,9 @@ export interface ChunkForDeliveryOptions {
 /**
  * Chunk text for delivery to a specific platform.
  *
- * Pure function -- no side effects, no adapter calls. Matches the chunking
- * logic previously inline in execution-pipeline.ts lines 661-686.
+ * Pure function -- no side effects, no adapter calls. Shared by the
+ * DeliveryService simple path and the execution pipeline so both produce
+ * identical chunk boundaries for the same input.
  *
  * @param text - The text to chunk (markdown or pre-formatted)
  * @param channelType - Target platform identifier

package/node_modules/@comis/core/dist/delivery/chunk-for-delivery.js

@@ -28,8 +28,9 @@ const PLATFORMS_NEEDING_TABLE_CONVERSION = new Set(["telegram", "signal", "whats
 /**
  * Chunk text for delivery to a specific platform.
  *
- * Pure function -- no side effects, no adapter calls. Matches the chunking
- * logic previously inline in execution-pipeline.ts lines 661-686.
+ * Pure function -- no side effects, no adapter calls. Shared by the
+ * DeliveryService simple path and the execution pipeline so both produce
+ * identical chunk boundaries for the same input.
  *
  * @param text - The text to chunk (markdown or pre-formatted)
  * @param channelType - Target platform identifier
@@ -69,7 +70,7 @@ export function chunkForDelivery(text, channelType, options) {
             minChars: options.chunkMinChars,
         });
     }
-    // Safety: never return empty array (design section 11.2)
+    // Safety: never return an empty array — delivery expects at least one chunk
     if (blocks.length === 0) {
         return [text];
     }

package/node_modules/@comis/core/dist/delivery/delivery-service.d.ts

@@ -1,21 +1,19 @@
 /**
  * DeliveryService factory.
  *
- * Replaces the standalone `deliverToChannel(adapter, ..., deps?)` export in
- * channels/src/shared/deliver-to-channel.ts. Two surgical differences:
- *  1. The global hook-runner lookup is replaced by `deps.hookRunner` (the
- *     `if (hookRunner)` null-guard is dropped — deps.hookRunner is REQUIRED).
- *  2. Function parameters lose the trailing optional `DeliverToChannelDeps`
- *     argument; deps is captured in closure. All `deps?.X` references become `deps.X`
- *     (`deps.deliveryQueue` is REQUIRED; eventBus / retryEngine / abortSignal /
- *     maxCharsOverride / replyMode remain optional, so the INNER `?.` on those
- *     fields stays). In-flight outbound `Promise` tracking is owned internally
+ * The single outbound-delivery entry point for channel adapters:
+ *  1. Hooks run through `deps.hookRunner` — REQUIRED, injected at
+ *     construction, never resolved from global state.
+ *  2. Deps are captured in closure at construction (`deps.deliveryQueue` is
+ *     REQUIRED; eventBus / retryEngine / abortSignal / maxCharsOverride /
+ *     replyMode are optional, so the INNER `?.` on those fields is
+ *     deliberate). In-flight outbound `Promise` tracking is owned internally
  *     by the factory and drained via the public `drainInFlight()` method —
  *     callers must NOT inject a tracking Set via deps.
  *
- * Hook execution order, traceId propagation, suppressError wrap on
- * after_delivery, and all `delivery:*` event emissions are byte-identical to
- * the prior standalone behavior.
+ * Hook execution order, traceId propagation, the suppressError wrap on
+ * after_delivery, and all `delivery:*` event emissions are load-bearing
+ * contracts pinned by the pipeline tests in delivery-service.test.ts.
  *
  * @module
  */
@@ -28,26 +26,21 @@ import type { DeliveryAdapter, DeliverToChannelOptions, DeliveryResult } from ".
 /**
  * Dependencies for createDeliveryService.
  *
- * `hookRunner` + `deliveryQueue` are REQUIRED — the closures that replace the
- * prior global hook-runner singleton and optional-deps shape (was an optional
- * `DeliverToChannelDeps` argument). `eventBus`, `retryEngine`,
- * `maxCharsOverride`, `replyMode`, and `abortSignal` are optional — they
- * preserve the per-call/per-instance optional knobs the standalone function
- * already accepts.
+ * `hookRunner` + `deliveryQueue` are REQUIRED. `eventBus`, `retryEngine`,
+ * `maxCharsOverride`, `replyMode`, and `abortSignal` are optional
+ * per-instance / per-call knobs.
  *
- * Note: in-flight outbound `Promise` tracking is now an internal concern of
+ * Note: in-flight outbound `Promise` tracking is an internal concern of
  * `createDeliveryService` (no `inFlightSends` deps field). The drain is
  * exposed via the public `drainInFlight()` method on the returned service.
- *
- * @see packages/channels/src/shared/deliver-to-channel.ts:DeliverToChannelDeps
  */
 export interface DeliveryServiceDeps {
-    /** Hook runner. REQUIRED — closes the global-state dependency. */
+    /** Hook runner. REQUIRED — hooks are injected, never resolved from global state. */
     hookRunner: HookRunner;
     /**
-     * Delivery queue for crash-safe persistence. REQUIRED (was optional in the
-     * standalone function's deps record). Use `createNoOpDeliveryQueue()` from
-     * `@comis/core` when the queue feature is disabled.
+     * Delivery queue for crash-safe persistence. REQUIRED. Use
+     * `createNoOpDeliveryQueue()` from `@comis/core` when the queue feature
+     * is disabled.
      */
     deliveryQueue: DeliveryQueuePort;
     /** Event bus. OPTIONAL — observability only; emits delivery:* events. */
@@ -59,14 +52,14 @@ export interface DeliveryServiceDeps {
     /** Reply mode for this delivery (off/first/all). OPTIONAL — default: "first". */
     replyMode?: "off" | "first" | "all";
     /**
-     * REACT-04 (Verified Learning, Phase 206-04): OPTIONAL outbound-message →
+     * OPTIONAL outbound-message →
      * trajectory binding for the DIRECT ack path. The recurring delivery-queue
      * DRAIN (setup-delivery.ts:drainDeliveryQueue) already binds; but the PRIMARY
      * inbound-reply path (setup-and-route → executeAndDeliver → execution-deliver
      * → this `deliverToChannel`) sends via the direct ack (enqueue in_flight →
-     * adapter.sendMessage → ack) and previously NEVER bound the minted reply id →
-     * trajectory, so a reaction on a normal agent reply map-missed and never drove
-     * learning (the 206-03 Stage-C live finding). Threaded here so the direct ack
+     * adapter.sendMessage → ack). Without this callback it would never bind the
+     * minted reply id → trajectory, so a reaction on a normal agent reply would
+     * map-miss and never drive learning. Threaded here so the direct ack
      * binds the SAME (messageId → scope) the drain does. `undefined` when learning-
      * outcome is disabled for every agent → the direct ack does ZERO extra work
      * (byte-identity). The same callback instance feeds BOTH the drain and this
@@ -75,7 +68,7 @@ export interface DeliveryServiceDeps {
      * Invoked ONLY on a successful ack with a non-null traceId AND a non-null
      * agentId (the request ALS) — a null traceId/agentId (a pre-executor / non-
      * agent send) is a FAIL-CLOSED skip: mis-attributing a reaction to the tenantId
-     * would corrupt cross-agent isolation (T-198-16), so we record nothing.
+     * would corrupt cross-agent isolation, so we record nothing.
      */
     recordOutboundMessage?: (messageId: string, scope: {
         traceId: string;
@@ -89,8 +82,8 @@ export interface DeliveryServiceDeps {
  * DeliveryService — outbound delivery + shutdown drain.
  *
  * No speculative methods — add ops only when call sites exist.
- * `abortSignal` rides on a per-call options channel (consistent with
- * the standalone function's `deps.abortSignal`).
+ * `abortSignal` rides on the per-call options argument, not on the
+ * construction-time deps.
  */
 export interface DeliveryService {
     deliverToChannel(adapter: DeliveryAdapter, channelId: string, text: string, options?: DeliverToChannelOptions & {

package/node_modules/@comis/core/dist/delivery/delivery-service.js

@@ -2,21 +2,19 @@
 /**
  * DeliveryService factory.
  *
- * Replaces the standalone `deliverToChannel(adapter, ..., deps?)` export in
- * channels/src/shared/deliver-to-channel.ts. Two surgical differences:
- *  1. The global hook-runner lookup is replaced by `deps.hookRunner` (the
- *     `if (hookRunner)` null-guard is dropped — deps.hookRunner is REQUIRED).
- *  2. Function parameters lose the trailing optional `DeliverToChannelDeps`
- *     argument; deps is captured in closure. All `deps?.X` references become `deps.X`
- *     (`deps.deliveryQueue` is REQUIRED; eventBus / retryEngine / abortSignal /
- *     maxCharsOverride / replyMode remain optional, so the INNER `?.` on those
- *     fields stays). In-flight outbound `Promise` tracking is owned internally
+ * The single outbound-delivery entry point for channel adapters:
+ *  1. Hooks run through `deps.hookRunner` — REQUIRED, injected at
+ *     construction, never resolved from global state.
+ *  2. Deps are captured in closure at construction (`deps.deliveryQueue` is
+ *     REQUIRED; eventBus / retryEngine / abortSignal / maxCharsOverride /
+ *     replyMode are optional, so the INNER `?.` on those fields is
+ *     deliberate). In-flight outbound `Promise` tracking is owned internally
  *     by the factory and drained via the public `drainInFlight()` method —
  *     callers must NOT inject a tracking Set via deps.
  *
- * Hook execution order, traceId propagation, suppressError wrap on
- * after_delivery, and all `delivery:*` event emissions are byte-identical to
- * the prior standalone behavior.
+ * Hook execution order, traceId propagation, the suppressError wrap on
+ * after_delivery, and all `delivery:*` event emissions are load-bearing
+ * contracts pinned by the pipeline tests in delivery-service.test.ts.
  *
  * @module
  */
@@ -170,7 +168,7 @@ export function createDeliveryService(deps) {
                     chunks = chunkBlocks(formatted, { mode: "paragraph", maxChars });
                 }
                 else if (PASSTHROUGH_PLATFORMS.has(adapter.channelType)) {
-                    // Passthrough platforms (discord, slack): raw markdown, use IR chunker
+                    // Passthrough platforms (discord, echo): raw markdown, use IR chunker
                     chunks = chunkForDelivery(formatted, adapter.channelType, {
                         maxChars,
                         useMarkdownIR: true,
@@ -188,7 +186,7 @@ export function createDeliveryService(deps) {
                 const ctx = tryGetContext();
                 const tenantId = ctx?.tenantId ?? "default";
                 const traceId = ctx?.traceId ?? null;
-                // REACT-02 (CR-01): the resolved agentId for the turn rides on the
+                // The resolved agentId for the turn rides on the
                 // request ALS (executor entry, context.ts:49). It is the partition the
                 // reaction trajectory map + the byte-identity gate key on downstream —
                 // NEVER the tenantId. Persisted into the queue entry's optionsJson below
@@ -196,14 +194,14 @@ export function createDeliveryService(deps) {
                 // to the REAL agent. `null` when absent (pre-executor paths) → the drain
                 // fails closed and does not map the message.
                 const agentId = ctx?.agentId ?? null;
-                // FLAG-2 (group reaction-spoof): the conversation PARTICIPANT — the inbound
+                // Group reaction-spoof guard: the conversation PARTICIPANT — the inbound
                 // sender whose message triggered this reply — rides on the request ALS as
                 // ctx.userId (the inbound pipeline sets userId = sessionKey.userId =
                 // msg.senderId). It is threaded onto the reaction trajectory binding so an
                 // unmapped group BYSTANDER cannot inherit defaultTrustLevel and spoof
                 // reaction-learning; only the participant (or an explicitly-mapped reactor)
                 // drives it. `undefined` on pre-resolution paths → the trust resolution fails
-                // safe to the prior defaultTrustLevel-for-unmapped behavior.
+                // safe to the standard defaultTrustLevel-for-unmapped behavior.
                 const participantId = ctx?.userId;
                 // Resolve delivery strategy
                 const strategy = options?.strategy ?? "all-or-abort";
@@ -282,17 +280,17 @@ export function createDeliveryService(deps) {
                     // 'in_flight' -> 'pending' for the drainer to retry. All ack/nack/fail
                     // statements are status-agnostic UPDATE-by-id, so no SQL change is needed.
                     let entryId = null;
-                    // deps.deliveryQueue is REQUIRED in DeliveryServiceDeps (was
-                    // optional in the standalone DeliverToChannelDeps).
+                    // deps.deliveryQueue is REQUIRED in DeliveryServiceDeps — no
+                    // null-guard needed here.
                     {
-                        // REACT-02 (CR-01): persist agentId into the serialized options so
+                        // Persist agentId into the serialized options so
                         // the drain reads the REAL agent (drain reads options.agentId). It is
                         // added to a SEPARATE persistence object — NOT to `sendOpts` — so it
                         // never rides into the platform `adapter.sendMessage` call. Omitted
                         // entirely when absent (pre-executor paths), keeping the drain
                         // fail-closed rather than mis-attributing to the tenantId.
                         //
-                        // FLAG-2: likewise persist the conversation participant (ctx.userId) so
+                        // Likewise persist the conversation participant (ctx.userId) so
                         // a reaction resolved via the DRAIN path (not the direct ack) is also
                         // participant-aware — an unmapped group bystander stays inert. Omitted
                         // when absent; the drain then threads `undefined` → fail-safe.
@@ -316,7 +314,7 @@ export function createDeliveryService(deps) {
                         });
                         if (enqueueResult.ok) {
                             entryId = enqueueResult.value;
-                            // delivery:enqueued is now emitted by the adapter (SqliteDeliveryQueueAdapter
+                            // delivery:enqueued is emitted by the adapter (SqliteDeliveryQueueAdapter
                             // emits inside enqueueInFlight after the INSERT succeeds -- single source of
                             // truth). No-op here.
                         }
@@ -369,17 +367,17 @@ export function createDeliveryService(deps) {
                                 timestamp: systemNowMs(),
                             });
                         }
-                        // --- REACT-04 (206-04): bind the minted reply id → trajectory on the
+                        // --- Bind the minted reply id → trajectory on the
                         // DIRECT ack path (the primary inbound-reply path sends HERE, not via
                         // the drain). Mirrors the drain's binding (setup-delivery.ts:287) so a
                         // reaction on this outbound reply resolves its trajectory. Fail-closed:
                         // a null traceId OR a null agentId (a pre-executor / non-agent send) is
                         // a SKIP — mis-attributing a reaction to the tenantId would corrupt
-                        // cross-agent isolation (T-198-16). The callback is undefined when
+                        // cross-agent isolation. The callback is undefined when
                         // learning-outcome is disabled for all agents → zero extra work
                         // (byte-identity). ReactionTrajectoryMap.record is idempotent by
                         // messageId, so a reply that ALSO traverses the drain (transient-nack →
-                        // retry) cannot double-bind. Diagnosability (§2.7): the bind shares the
+                        // retry) cannot double-bind. Diagnosability: the bind shares the
                         // SAME messageId as the delivery:acked event just emitted (so the
                         // attribution is reconstructable from the event trail), and the
                         // downstream observeReactionNonFatal INFO line is the proof it resolved
@@ -390,19 +388,19 @@ export function createDeliveryService(deps) {
                                 tenantId,
                                 agentId,
                                 sessionId: traceId, // session identity falls back to the trajectory id (scope-consistent with the drain)
-                                // FLAG-2: bind the conversation participant (the inbound sender) so a
+                                // Bind the conversation participant (the inbound sender) so a
                                 // reaction from an unmapped group bystander is inert (resolves to
                                 // "external"); only the participant inherits defaultTrustLevel.
                                 participantId,
                             });
-                            // WR-01 (206-05): the bind above is otherwise SILENT. Emit a
+                            // The bind above is otherwise SILENT. Emit a
                             // positive, counts-only `delivery:reply_bound` so the primary-path
                             // attribution is observable — a later reaction map-miss can then be
                             // told apart ("bind fired → entry evicted" vs "bind never fired")
                             // from the event trail in one obs call, with no daemon.log grep.
                             // Same fail-closed branch as the bind; shares `messageId` with the
                             // `delivery:acked` event just emitted. IDS/closed-scalars ONLY —
-                            // never a body or a secret (§2.7 / SEC-01); `agentId` is the REAL
+                            // never a body or a secret (redaction discipline); `agentId` is the REAL
                             // agent (never the tenantId). Only on the learning-enabled path
                             // (recordOutboundMessage defined) → byte-identity when disabled.
                             deps.eventBus?.emit("delivery:reply_bound", {

package/node_modules/@comis/core/dist/delivery/format-for-channel.d.ts

@@ -18,7 +18,7 @@
  *
  * For platforms in `PLATFORMS_NEEDING_IR_RENDER`, parses the text through
  * the Markdown IR pipeline and renders to the target format. For all other
- * platforms (discord, slack, gateway, echo, unknown), returns text unchanged.
+ * platforms (discord, gateway, echo, unknown), returns text unchanged.
  *
  * @param text - The markdown text to convert
  * @param channelType - Target platform identifier (e.g. "telegram", "discord")

package/node_modules/@comis/core/dist/delivery/format-for-channel.js

@@ -39,7 +39,7 @@ const PLATFORMS_NEEDING_IR_RENDER = new Set([
  *
  * For platforms in `PLATFORMS_NEEDING_IR_RENDER`, parses the text through
  * the Markdown IR pipeline and renders to the target format. For all other
- * platforms (discord, slack, gateway, echo, unknown), returns text unchanged.
+ * platforms (discord, gateway, echo, unknown), returns text unchanged.
  *
  * @param text - The markdown text to convert
  * @param channelType - Target platform identifier (e.g. "telegram", "discord")

package/node_modules/@comis/core/dist/delivery/markdown-ir.js

@@ -23,9 +23,9 @@
  *    consumed by the italic `_text_` alternative. Without this branch,
  *    a URL like `code_challenge_method=…` matches `_(.+?)_` and renders
  *    as `<i>challenge</i>method=…`, dropping every paired `_` from the
- *    surface form. Higgsfield-class providers receive params with
- *    truncated names (`responsetype`, `redirecturi`, …) and return 400
- *    `redirect_uri must be a valid absolute URL` (observed 2026-05-28).
+ *    surface form. OAuth providers then receive params with truncated
+ *    names (`responsetype`, `redirecturi`, …) and return 400
+ *    `redirect_uri must be a valid absolute URL`.
  *    Excludes `)` so URLs in parens (`(See https://x.com/)`) don't grab
  *    the trailing close-paren; we accept that legitimate URLs with `)`
  *    in their path (rare; Wikipedia is the canonical example) will be
@@ -76,7 +76,7 @@ export function parseInlineSpans(text) {
         else if (match[2] !== undefined) {
             // Bare URL: pass through as a self-pointing link so the URL bytes
             // (including every `_`) reach the renderer unmodified. See INLINE_RE
-            // docblock for the Higgsfield-OAuth bug this closes.
+            // docblock for the OAuth-URL corruption this closes.
             const url = match[2];
             spans.push({
                 type: "link",
@@ -309,7 +309,8 @@ export function parseMarkdownToIR(markdown) {
                 rawLines.push(lines[i]);
                 i++;
             }
-            // If not closed, rawLines extends to end of input (per spec)
+            // If not closed, rawLines extends to end of input (CommonMark treats an
+            // unclosed fence as running to the end of the document)
             blocks.push({
                 type: "code_block",
                 spans: [],

package/node_modules/@comis/core/dist/delivery/types.d.ts

@@ -2,10 +2,10 @@
  * Core-owned delivery types.
  *
  * These types live in core/src/delivery/ so createDeliveryService can be
- * defined in core without a core → channels back-edge. The actual
- * `deliverToChannel` function and value-level helpers
+ * defined in core without a core → channels back-edge. The delivery
+ * pipeline itself lives in delivery-service.ts; the value-level helpers
  * (QUEUE_BACKOFF_SCHEDULE_MS, computeQueueBackoff, resolveChunkLimit)
- * live in channels/src/shared/deliver-to-channel.ts.
+ * live in queue-backoff.ts.
  */
 import type { SendMessageOptions } from "../ports/channel.js";
 import type { Result } from "@comis/shared";

package/node_modules/@comis/core/dist/delivery/types.js

@@ -3,9 +3,9 @@
  * Core-owned delivery types.
  *
  * These types live in core/src/delivery/ so createDeliveryService can be
- * defined in core without a core → channels back-edge. The actual
- * `deliverToChannel` function and value-level helpers
+ * defined in core without a core → channels back-edge. The delivery
+ * pipeline itself lives in delivery-service.ts; the value-level helpers
  * (QUEUE_BACKOFF_SCHEDULE_MS, computeQueueBackoff, resolveChunkLimit)
- * live in channels/src/shared/deliver-to-channel.ts.
+ * live in queue-backoff.ts.
  */
 export {};

package/node_modules/@comis/core/dist/domain/approval-request.js

@@ -20,7 +20,7 @@ import { z } from "zod";
 export const ApprovalRequestSchema = z.strictObject({
     /** Unique identifier for this approval request */
     requestId: z.string().uuid(),
-    /** 12-char base62 callback-safe identifier minted by the approval-gate (§6.4.1) */
+    /** 12-char base62 callback-safe identifier minted by the approval-gate */
     shortId: z.string().length(12).regex(/^[0-9A-Za-z]+$/),
     /** Name of the tool being invoked */
     toolName: z.string(),
@@ -59,7 +59,7 @@ export const ApprovalResolutionSchema = z.strictObject({
 /** Schema for a serialized pending approval request (for restart persistence). */
 export const SerializedApprovalRequestSchema = z.strictObject({
     requestId: z.string().uuid(),
-    /** 12-char base62 callback-safe identifier minted by the approval-gate (§6.4.1) */
+    /** 12-char base62 callback-safe identifier minted by the approval-gate */
     shortId: z.string().length(12).regex(/^[0-9A-Za-z]+$/),
     toolName: z.string(),
     action: z.string(),

package/node_modules/@comis/core/dist/domain/channel-capability.d.ts

@@ -14,6 +14,7 @@ export declare const ChannelCapabilitySchema: z.ZodObject<{
             components: "components";
             blockkit: "blockkit";
             quickreply: "quickreply";
+            adaptivecard: "adaptivecard";
         }>>;
     }, z.core.$strict>>;
     limits: z.ZodObject<{

package/node_modules/@comis/core/dist/domain/channel-capability.js

@@ -20,11 +20,12 @@ const ChannelFeaturesSchema = z.strictObject({
     typing: z.boolean().default(false),
     /** Whether the channel supports threads/topics (activity strategy hint). */
     threads: z.boolean().default(false),
-    /** Interactive-button capability flavour for this channel. "none" when the
-     *  platform has no button surface. Defaults exist only as a safety net for
-     *  *new* plugins (§19.5); the 10 in-tree plugins declare this explicitly. */
+    /** Interactive-button capability flavour for this channel: one of
+     *  "inline", "components", "blockkit", "quickreply", "adaptivecard", or
+     *  "none" when the platform has no button surface. The default exists only
+     *  as a safety net for *new* plugins; in-tree plugins declare it explicitly. */
     buttons: z
-        .enum(["inline", "components", "blockkit", "quickreply", "none"])
+        .enum(["inline", "components", "blockkit", "quickreply", "none", "adaptivecard"])
         .default("none"),
 });
 export const ChannelCapabilitySchema = z.strictObject({

package/node_modules/@comis/core/dist/domain/chat-type.d.ts

@@ -1,6 +1,5 @@
 /**
- * ChatType — the narrowed 3-value chat classification introduced by the
- * activity milestone (spec §4.6).
+ * ChatType — the narrowed 3-value chat classification.
  *
  * Narrows the 5-value `NormalizedMessage.chatType` enum
  * (`"dm" | "group" | "thread" | "channel" | "forum"`) to the 3 values
@@ -18,8 +17,8 @@ export type ChatType = z.infer<typeof ChatTypeSchema>;
 /** Source enum on `NormalizedMessage.chatType` (5 values). */
 export type NormalizedChatType = "dm" | "group" | "thread" | "channel" | "forum";
 /**
- * Narrow the 5-value `NormalizedMessage.chatType` to the 3-value `ChatType`
- * (spec §4.6). `dm → direct`; `thread`/`forum` fold to their parent `group`;
+ * Narrow the 5-value `NormalizedMessage.chatType` to the 3-value `ChatType`.
+ * `dm → direct`; `thread`/`forum` fold to their parent `group`;
  * `group` and `channel` pass through. Closed `switch` with an exhaustive
  * `_exhaustive: never` default (AGENTS.md §2.8): adding a source value without
  * a `case` fails `tsc` at the default assignment.

package/node_modules/@comis/core/dist/domain/chat-type.js

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * ChatType — the narrowed 3-value chat classification introduced by the
- * activity milestone (spec §4.6).
+ * ChatType — the narrowed 3-value chat classification.
  *
  * Narrows the 5-value `NormalizedMessage.chatType` enum
  * (`"dm" | "group" | "thread" | "channel" | "forum"`) to the 3 values
@@ -12,8 +11,8 @@
 import { z } from "zod";
 export const ChatTypeSchema = z.enum(["direct", "group", "channel"]);
 /**
- * Narrow the 5-value `NormalizedMessage.chatType` to the 3-value `ChatType`
- * (spec §4.6). `dm → direct`; `thread`/`forum` fold to their parent `group`;
+ * Narrow the 5-value `NormalizedMessage.chatType` to the 3-value `ChatType`.
+ * `dm → direct`; `thread`/`forum` fold to their parent `group`;
  * `group` and `channel` pass through. Closed `switch` with an exhaustive
  * `_exhaustive: never` default (AGENTS.md §2.8): adding a source value without
  * a `case` fails `tsc` at the default assignment.

package/node_modules/@comis/core/dist/domain/durable-run.d.ts

@@ -1,12 +1,12 @@
 /**
  * DurableRunRecord: the Zod-validated checkpoint a long-running agent run
- * persists so a daemon restart can resume it (Phase 216, DUR-01/DUR-02/DUR-03).
+ * persists so a daemon restart can resume it.
  *
  * The record is read back on resume and decides what the rehydrated run may do,
- * so the schema is the trust boundary (T-216-01): `caps` is the closed
+ * so the schema is the trust boundary: `caps` is the closed
  * AgentCapability union (a tampered cap string cannot rehydrate), `status` is a
  * closed four-state set, and `strictObject` rejects any column the store DDL
- * adds without a matching field — so the schema and the SQLite table (Plan 02)
+ * adds without a matching field — so the schema and the SQLite table
  * move in lockstep, exactly like `video-job-row-schema.ts`.
  *
  * `caps` reuses the single AGENT_CAPABILITIES tuple from
@@ -22,7 +22,7 @@ import { z } from "zod";
  * The closed AgentCapability union as a Zod schema, built from the single
  * AGENT_CAPABILITIES tuple (SSOT in security/capability.ts). A persisted cap
  * outside this set fails `parseDurableRunRecord` — a tampered/foreign cap
- * string can never rehydrate into a resumed run's authority (T-216-01).
+ * string can never rehydrate into a resumed run's authority.
  */
 export declare const AgentCapabilitySchema: z.ZodEnum<{
     "orch:spawn": "orch:spawn";
@@ -35,10 +35,11 @@ export declare const AgentCapabilitySchema: z.ZodEnum<{
     "orch:analyze": "orch:analyze";
     "orch:write": "orch:write";
     "orch:browse": "orch:browse";
+    "orch:mcp": "orch:mcp";
 }>;
 /**
  * The closed run-status set. `running` rows are the boot-resume scan
- * (`listResumable`); `revoked` is the DUR-03 terminal state a `invalidateForRevoke`
+ * (`listResumable`); `revoked` is the terminal state a `invalidateForRevoke`
  * write flips a record to so resume can never re-mint a revoked run.
  */
 export declare const DurableRunStatusSchema: z.ZodEnum<{
@@ -70,6 +71,7 @@ export declare const DurableRunRecordSchema: z.ZodObject<{
         "orch:analyze": "orch:analyze";
         "orch:write": "orch:write";
         "orch:browse": "orch:browse";
+        "orch:mcp": "orch:mcp";
     }>>;
     leaseIds: z.ZodArray<z.ZodString>;
     budgetConsumed: z.ZodNumber;
@@ -82,6 +84,8 @@ export declare const DurableRunRecordSchema: z.ZodObject<{
         revoked: "revoked";
     }>;
     lastHeartbeatAt: z.ZodNumber;
+    scriptRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    checkpointRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type DurableRunRecord = z.infer<typeof DurableRunRecordSchema>;
 /**