comisai 1.0.44 → 1.0.46

package/node_modules/@comis/orchestrator/dist/execution/activity-turn-coordinator.d.ts

@@ -1,6 +1,5 @@
 /**
- * ActivityTurnCoordinator — owns the turn boundary in the orchestrator
- * (spec §4.5/§4.6).
+ * ActivityTurnCoordinator — owns the turn boundary in the orchestrator.
  *
  * One coordinator is constructed per turn and disposed at turn end. It:
  *   1. subscribes to the canonical activity stream for the turn
@@ -10,14 +9,14 @@
  *      (chat/acp) to build the next `ActivityRenderFrame`, and calls
  *      `renderer.apply(frame)` debounced to one paint per 800ms via the
  *      injected `TimerPort` (`handle.cancel()` for cancellation — never a raw
- *      timer global, Pitfall 7),
+ *      timer global),
  *   3. on `finalize(outcome)` enforces the delete gate:
  *      • any observed `ActivityEvent{status:"failed"}` reclassifies the
  *        outcome to `kind:"failure"` with NO delete branch — even when delivery
  *        itself succeeded,
  *      • a `success` / `success_with_recovered_failures` outcome calls
  *        `renderer.finalize` ONLY after `outcome.delivery.deliveredAtMs` is
- *        acknowledged (delete never precedes the answer; §7.3),
+ *        acknowledged (delete never precedes the answer),
  *      • `failure` / `silent` / `aborted` call `renderer.finalize` with the
  *        renderer's own keep/delete policy (no success-delete forced here),
  *   4. translates any `ActivityRenderError` from `apply`/`finalize` into an
@@ -30,7 +29,7 @@
  *
  * @module
  */
-import type { ActivityEvent, ActivityStreamPort, ActivityRenderFrame, ActivityRenderError, ChannelActivityRenderer, TurnActivityContext, TurnOutcome, ProjectionConfig, PlanSnapshot, ClockPort, TimerPort, ComisLogger } from "@comis/core";
+import type { ActivityEvent, ActivityStreamPort, ActivityRenderFrame, ActivityRenderError, ChannelActivityRenderer, TurnActivityContext, TurnOutcome, TypedEventBus, ProjectionConfig, PlanSnapshot, ClockPort, TimerPort, ComisLogger } from "@comis/core";
 import type { Result } from "@comis/shared";
 /**
  * Projection function the coordinator drives per render tick. Unifies the chat
@@ -46,7 +45,7 @@ export type ActivityProjection = (events: readonly ActivityEvent[], config: Proj
  * Minimal PlanUpdate shape the coordinator's PlanStream subscription expects.
  *
  * Structural type defined LOCALLY here (NOT imported from `@comis/observability`)
- * so the orchestrator preserves its §4.7 boundary: imports ONLY
+ * so the orchestrator preserves its boundary: imports ONLY
  * `@comis/core` and never `@comis/observability` (see src/index.ts:36 and
  * execution-pipeline.ts:131). The observability `createPlanStream(...)` returns
  * a `PlanStream` whose `PlanUpdate` payload structurally satisfies THIS shape;
@@ -83,13 +82,13 @@ export interface PlanStream {
     subscribe(onPlanUpdate: (update: PlanUpdate) => void): () => void;
 }
 /**
- * Live read of the operator kill switches for the agent owning this turn
- * (§22.2). Returns the per-agent `activity` slice the gate cares about:
+ * Live read of the operator kill switches for the agent owning this turn.
+ * Returns the per-agent `activity` slice the gate cares about:
  * the agent-wide `emergencyDisabled` stop and the per-renderer `channels` enable
  * map (keyed by `TurnActivityContext.rendererKey`). MUST be a getter, not a
  * snapshot — the coordinator reads it on every `flushApply` so an in-memory
- * `config.write` flip hot-reloads without reconstructing the coordinator
- * (Pitfall 4). `undefined` (getter absent, or the agent has no `activity`
+ * `config.write` flip hot-reloads without reconstructing the coordinator.
+ * `undefined` (getter absent, or the agent has no `activity`
  * config) means "no suppression" — the un-wired composition path is unaffected.
  */
 export type ActivityKillSwitch = () => {
@@ -97,7 +96,7 @@ export type ActivityKillSwitch = () => {
     channels: Record<string, {
         enabled: boolean;
     }>;
-    /** §22.2 operator opt-in to default-ON: when true, a rendererKey with no
+    /** Operator opt-in to default-ON: when true, a rendererKey with no
      *  explicit `channels` entry is enabled (an explicit entry still wins).
      *  Absent/false preserves the fail-closed Day-0 posture. */
     defaultEnabled?: boolean;
@@ -162,9 +161,16 @@ export interface ActivityTurnCoordinatorDeps {
      * `releaseSubscription` (cleanup runs even on aborted turns via try/finally).
      */
     planStream?: PlanStream;
+    /**
+     * Optional event bus for the `activity:turn_finalized` emit — the
+     * user-surface trajectory record (which terminal state the renderer painted,
+     * and whether a failed event reclassified the outcome). Absent → no emit
+     * (existing callers unchanged); the daemon composition root injects it.
+     */
+    eventBus?: TypedEventBus;
 }
 /**
- * In-process counter snapshot (spec §20.1). Mirrors the observability
+ * In-process counter snapshot. Mirrors the observability
  * ActivityStream pattern — there is no metrics-sink primitive, so counters are
  * surfaced as a snapshot for the daemon scrape + the test harness.
  */
@@ -186,7 +192,7 @@ export interface ActivityTurnCounters {
      */
     circuitBreakerTripped: number;
 }
-/** The per-turn coordinator handle (§4.6). */
+/** The per-turn coordinator handle. */
 export interface ActivityTurnCoordinator {
     /** Subscribe for the turn. Call once at turn start. */
     start(ctx: TurnActivityContext): void;

package/node_modules/@comis/orchestrator/dist/execution/activity-turn-coordinator.js

@@ -4,7 +4,7 @@ import { randomUUID } from "node:crypto";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-/** Debounce window for `renderer.apply` — at most one paint per 800ms (§5/§9). */
+/** Debounce window for `renderer.apply` — at most one paint per 800ms. */
 const APPLY_DEBOUNCE_MS = 800;
 // ---------------------------------------------------------------------------
 // Helpers
@@ -78,7 +78,7 @@ export function createActivityTurnCoordinator(deps) {
     let disposed = false;
     // The turn's root activity id, minted once at start(). The spawning
     // turn's root is the parent of every sub-agent ActivityEvent (the spawn event
-    // carries parentSessionKey, not a parent activityId — §17.3 / Assumption A2).
+    // carries parentSessionKey, not a parent activityId).
     let turnRootActivityId;
     // Active sub-agent stack (runId-less here — the coordinator keys on the
     // event's own activityId) for nested-spawn parent resolution. The top of the
@@ -107,12 +107,12 @@ export function createActivityTurnCoordinator(deps) {
      * Kill-switch gate. Returns true when this renderer's activity must be
      * suppressed for the current turn. Reads the LIVE getter on every call (no
      * captured snapshot) so an in-memory config.write flip hot-reloads without
-     * reconstructing the coordinator (Pitfall 4 / §22.2):
+     * reconstructing the coordinator:
      *   • emergencyDisabled === true → suppress ALL activity for the agent,
      *   • an explicit channels[ctx.rendererKey] entry always wins: enabled:true
      *     renders, enabled:false suppresses (per-channel opt-out),
-     *   • no explicit entry → suppress UNLESS defaultEnabled === true (§22.2
-     *     operator opt-in to default-ON); fail-closed otherwise.
+     *   • no explicit entry → suppress UNLESS defaultEnabled === true (operator
+     *     opt-in to default-ON); fail-closed otherwise.
      * When the getter is absent or returns undefined, nothing is suppressed (the
      * un-wired composition path is unaffected — daemon injection is the documented
      * follow-on).
@@ -178,8 +178,8 @@ export function createActivityTurnCoordinator(deps) {
         if (key !== undefined && deps.breaker?.isTripped(key) === true)
             return;
         // Pass the cached `latestPlanSnapshot` as the projection's
-        // 4th arg so chatProjection threads it onto frame.planSnapshot (Pitfall 6
-        // — supersedes silent forward of prevFrame's stale snapshot).
+        // 4th arg so chatProjection threads it onto frame.planSnapshot
+        // (this supersedes a silent forward of prevFrame's stale snapshot).
         const frame = deps.projection(events, deps.config, prevFrame, latestPlanSnapshot);
         prevFrame = frame;
         const result = await deps.renderer.apply(frame);
@@ -199,7 +199,7 @@ export function createActivityTurnCoordinator(deps) {
     /** Schedule a debounced flush, collapsing rapid events to one apply/800ms. */
     function scheduleApply() {
         // Cancel the prior pending paint via the opaque handle — never a raw timer
-        // global (Pitfall 7).
+        // global.
         debounceHandle?.cancel();
         debounceHandle = deps.timer.setTimeout(() => {
             // The apply runs async; render errors are surfaced as WARN inside
@@ -218,7 +218,7 @@ export function createActivityTurnCoordinator(deps) {
     /**
      * Supply `parentActivityId` for a sub-agent event from the active
      * stack. The stream emits sub-agent events WITHOUT a parent link (it has no
-     * turn state); the coordinator (the §4.5 single owner) resolves it here:
+     * turn state); the coordinator (the single owner) resolves it here:
      *   • phase:"start" lacking a parent → parent is the enclosing sub-agent (top
      *     of the stack) for a nested spawn, else the turn's root activity; the
      *     event's own activityId is then pushed so a deeper spawn links to it,
@@ -270,8 +270,8 @@ export function createActivityTurnCoordinator(deps) {
     async function runFinalize(outcome) {
         counters.turnDurationMs = deps.clock.now() - startedAtMs;
         // (1) Reclassify: any observed failed event flips a non-failure outcome to
-        // failure with NO delete branch — even if delivery itself succeeded
-        // (§19.3). Already-failure / silent / aborted outcomes are left as-is.
+        // failure with NO delete branch — even if delivery itself succeeded.
+        // Already-failure / silent / aborted outcomes are left as-is.
         let effective = outcome;
         if (sawFailedEvent && (outcome.kind === "success" || outcome.kind === "success_with_recovered_failures")) {
             const failedEvents = events.filter((e) => e.status === "failed");
@@ -281,7 +281,31 @@ export function createActivityTurnCoordinator(deps) {
                 failedEvents,
             };
         }
-        // (2) Success path: the delete (owned by renderer.finalize per §7.3) must
+        // Announce the EFFECTIVE terminal surface state (the user-visible pill's
+        // fate is a pure function of this outcome + the strategy) so `explain` can
+        // answer "what did the user's chat show this turn" from the trajectory —
+        // the reclassify above used to be reconstructable only from source.
+        // Content-free: closed outcome kind + closed ErrorKind + a fixed
+        // named-constant reason + counts.
+        if (deps.eventBus && turnCtx !== undefined) {
+            deps.eventBus.emit("activity:turn_finalized", {
+                sessionKey: turnCtx.sessionKey,
+                agentId: turnCtx.agentId,
+                channelType: turnCtx.channelType,
+                strategy: deps.renderer.strategy,
+                outcome: effective.kind,
+                ...(effective.kind === "failure" && effective.errorKind !== undefined
+                    ? { errorKind: effective.errorKind }
+                    : {}),
+                ...(effective.kind === "failure" && effective.reason !== undefined
+                    ? { reason: effective.reason }
+                    : {}),
+                reclassified: effective !== outcome,
+                failedEventCount: events.filter((e) => e.status === "failed").length,
+                timestamp: deps.clock.now(),
+            });
+        }
+        // (2) Success path: the delete (owned by renderer.finalize) must
         // NOT precede the assistant message landing. Gate on deliveredAtMs.
         if (effective.kind === "success" || effective.kind === "success_with_recovered_failures") {
             const deliveredAtMs = effective.delivery.deliveredAtMs;
@@ -325,7 +349,7 @@ export function createActivityTurnCoordinator(deps) {
             // from session A reaching a render of session B. The adapter maps the
             // observability PlanUpdate shape to the core PlanSnapshot shape AND
             // runs redactValue on each description before exposing it as `label`
-            // (Security V9 — SEP descriptions are LLM-extracted from the model
+            // (SEP descriptions are LLM-extracted from the model
             // response and could echo a user message including a secret). On a new
             // snapshot, schedule a debounced apply so the renderer paints the
             // updated checkbox header within one tick.

package/node_modules/@comis/orchestrator/dist/execution/execution-deliver.d.ts

@@ -15,13 +15,13 @@ export type DeliverDeps = Pick<ExecutionPipelineDeps, "eventBus" | "logger" | "s
      * Optional injected clock. When present, `deliveredAtMs` is read from it
      * (deterministic in tests). When absent, the sanctioned-root `systemNowMs()`
      * is used — this stage is one of the sanctioned roots for `systemNowMs`
-     * (it already uses it for delivery metrics). §16.6.
+     * (it already uses it for delivery metrics).
      */
     clock?: ClockPort;
 };
 /**
- * `delivery.visibleReplies` policy threaded into the delivery stage
- * (§16.3). The resolved per-chat-type mode + whether the `message` tool acted
+ * `delivery.visibleReplies` policy threaded into the delivery stage.
+ * The resolved per-chat-type mode + whether the `message` tool acted
  * (`send`/`reply`/`attach`) this turn. When the policy for the inbound chat type
  * is `"message_tool"` and the tool did NOT act, the final assistant text is
  * suppressed (the activity/approval surfaces and lifecycle reactions are

package/node_modules/@comis/orchestrator/dist/execution/execution-deliver.js

@@ -11,7 +11,7 @@ import { tryGetContext, chunkForDelivery, createBlockRetryGuard, systemNowMs, sa
 import { ok, err } from "@comis/shared";
 import { buildThreadSendOpts } from "./execution-pipeline.js";
 import { createBlockPacer, coalesceBlocks } from "@comis/channels";
-/** Truncation cap for the failure receipt's `lastError` (§ DeliveryFailureReceipt). */
+/** Truncation cap for the failure receipt's `lastError`. */
 const MAX_LAST_ERROR_CHARS = 200;
 /** A success receipt for a turn where delivery was intentionally suppressed (visibleReplies). */
 const SUPPRESSED_RECEIPT = {
@@ -30,7 +30,7 @@ const SUPPRESSED_RECEIPT = {
  * and delivery metrics logging.
  */
 export async function deliverExecutionResponse(deps, adapter, effectiveMsg, finalDeliveryText, blockStreamCfg, activePacers, replyTo, deliverySignal, typingLifecycle, enforcement) {
-    // === VISIBLE-REPLIES ENFORCEMENT (§16.3) ===
+    // === VISIBLE-REPLIES ENFORCEMENT ===
     // Runs AFTER the response filter (the caller passes the post-filter
     // finalDeliveryText) and BEFORE any assistant-text delivery. When the chat
     // type's policy is "message_tool" and the model did not call the `message`
@@ -199,20 +199,56 @@ export async function deliverExecutionResponse(deps, adapter, effectiveMsg, fina
     finally {
         activePacers.delete(pacer);
     }
-    // §16.6: capture the settle timestamp the moment the last chunk's send-promise
+    // Capture the settle timestamp the moment the last chunk's send-promise
     // resolved — i.e. right after pacer.deliver settles, before any post-delivery
     // bookkeeping. Injected ClockPort when present (deterministic tests); otherwise
     // the sanctioned-root systemNowMs (this stage is a sanctioned root). Used as
     // deliveredAtMs on the success receipt and failedAtMs on the failure receipt.
     const settledAtMs = deps.clock ? deps.clock.now() : systemNowMs();
+    // Blocks the pacer never attempted because the external signal aborted
+    // mid-delivery (its hard-stop skips the remainder WITHOUT sending). Counting
+    // only FAILED chunks read a fully-skipped delivery as success — observed
+    // live: a spend-aborted turn logged success:true while the user received
+    // nothing. The skip is not a platform failure (nothing was attempted), so
+    // the receipt shape is unchanged; the LOGS must carry the truth.
+    const skippedChunks = deliverySignal.aborted
+        ? Math.max(0, coalescedGroups.length - (deliveredChunks + failedChunks))
+        : 0;
     const deliveryCtx = tryGetContext();
+    if (skippedChunks > 0) {
+        deps.logger.warn({
+            traceId: deliveryCtx?.traceId,
+            channelType: effectiveMsg.channelType ?? "unknown",
+            chatId: effectiveMsg.channelId,
+            skippedChunks,
+            totalChunks: coalescedGroups.length,
+            hint: "Execution abort cut delivery short — the remaining blocks were never sent and the user did not receive them; check the execution:aborted reason for this turn",
+            errorKind: "precondition",
+        }, "Block delivery skipped by aborted execution");
+        // The pacer's hard stop never reaches deliverToChannel, so none of the
+        // delivery events fire — the trajectory records NOTHING for a turn whose
+        // reply was never sent. Announce the skip on the existing
+        // delivery:aborted event (chunksDelivered counts what DID go out before
+        // the signal fired) so `explain` shows the undelivered turn.
+        deps.eventBus.emit("delivery:aborted", {
+            channelId: effectiveMsg.channelId,
+            channelType: effectiveMsg.channelType ?? "unknown",
+            reason: typeof deliverySignal.reason === "string" ? deliverySignal.reason : "aborted",
+            chunksDelivered: deliveredChunks,
+            totalChunks: coalescedGroups.length,
+            durationMs: Math.round(performance.now() - deliveryStartMs),
+            origin: "agent",
+            timestamp: systemNowMs(),
+        });
+    }
     deps.logger.debug({
         traceId: deliveryCtx?.traceId,
         step: "block-delivery",
         rawBlocks: blocks.length,
         coalescedGroups: coalescedGroups.length,
         chatId: effectiveMsg.channelId,
-        success: failedChunks === 0,
+        success: failedChunks === 0 && skippedChunks === 0,
+        ...(skippedChunks > 0 ? { skippedChunks } : {}),
     }, "Block delivery complete");
     // Delivery complete INFO bookend
     const deliveryDurationMs = Math.round(performance.now() - deliveryStartMs);
@@ -231,7 +267,7 @@ export async function deliverExecutionResponse(deps, adapter, effectiveMsg, fina
     if (typingLifecycle && blockStreamCfg.typingMode === "message") {
         typingLifecycle.markRunComplete();
     }
-    // === DELIVERY RECEIPT (§16.6) ===
+    // === DELIVERY RECEIPT ===
     // Any failed chunk => err(DeliveryFailureReceipt) so the coordinator can
     // classify the turn as kind:"failure" and keep the activity trail.
     if (failedChunks > 0 || firstFailure) {

package/node_modules/@comis/orchestrator/dist/execution/execution-execute.js

@@ -110,14 +110,14 @@ tools, directives) {
             traceId: tryGetContext()?.traceId ?? randomUUID(),
             tenantId: sessionKey.tenantId,
             userId: sessionKey.userId,
-            // REACT-04 (206-04): stamp the RESOLVED agentId onto the request ALS so
+            // Stamp the RESOLVED agentId onto the request ALS so
             // the delivery stage (deliverToChannel, which runs inside this context)
             // reads ctx.agentId and binds the outbound reply → trajectory (the
             // reaction-attribution keystone). Without this, ctx.agentId is undefined
             // at delivery → the reply's agentId is never persisted into the queue
             // optionsJson and BOTH binding paths (the direct ack + the drain)
-            // fail-closed, so a reaction on the reply map-misses (the 206-03 live
-            // finding). agentId is the resolved-agent parameter (non-empty).
+            // fail-closed, so a reaction on the reply map-misses.
+            // agentId is the resolved-agent parameter (non-empty).
             agentId,
             sessionKey: formatSessionKey(sessionKey),
             startedAt: systemNowMs(),
@@ -175,8 +175,13 @@ tools, directives) {
     if (accumulated) {
         accumulated = sanitizeAssistantResponse(accumulated);
     }
-    // Resource aborts with recovered response
-    const RESOURCE_ABORT_REASONS = new Set(["budget_exceeded", "max_steps", "context_exhausted", "circuit_breaker"]);
+    // Resource aborts with recovered response. spend_exceeded (the priced
+    // observability.spend / per-root autonomy.budget kill) belongs here: the
+    // abort path substitutes the "[Stopped: spend_exceeded]" notice as the
+    // response, and delivering it through the still-aborted signal made the
+    // block pacer hard-skip every block — the user got permanent silence for a
+    // budget stop while the delivery log read success.
+    const RESOURCE_ABORT_REASONS = new Set(["budget_exceeded", "spend_exceeded", "max_steps", "context_exhausted", "circuit_breaker"]);
     const resourceAborted = deliveryAbortController.signal.aborted && deliveryAbortReason != null && RESOURCE_ABORT_REASONS.has(deliveryAbortReason);
     const recoveryAbortController = resourceAborted ? new AbortController() : undefined;
     const deliverySignal = recoveryAbortController?.signal ?? deliveryAbortController.signal;

package/node_modules/@comis/orchestrator/dist/execution/execution-pipeline.d.ts

@@ -81,10 +81,10 @@ export interface ExecutionPipelineDeps {
     /** When true, only content inside <final> blocks reaches users. */
     enforceFinalTag?: boolean;
     /**
-     * The orchestrator-facing activity stream port (§17.7). Injected at
+     * The orchestrator-facing activity stream port. Injected at
      * the daemon composition root (the observability `createActivityStream` impl).
      * Optional — when absent (or `coordinatorFactory` is absent) the turn runs
-     * exactly as before with no activity coordinator. The orchestrator depends ONLY
+     * with no activity coordinator. The orchestrator depends ONLY
      * on this core port shape; it never imports `@comis/observability`.
      */
     activityStreamPort?: ActivityStreamPort;
@@ -92,7 +92,7 @@ export interface ExecutionPipelineDeps {
      * Per-turn coordinator factory. `executeAndDeliver` calls this once
      * per turn with the turn's {@link TurnActivityContext}, returning an unstarted
      * {@link ActivityTurnCoordinator}; the pipeline `start()`s it on turn begin and
-     * `finalize(outcome)`s it after delivery (gated on the §16.6 receipt). The
+     * `finalize(outcome)`s it after delivery (gated on the delivery receipt). The
      * factory captures the per-channel renderer + TimerPort/ClockPort/logger at the
      * composition root and resolves the renderer by `ctx.channelType`.
      * Optional — present only when activity rendering is wired for the turn.

package/node_modules/@comis/orchestrator/dist/execution/execution-pipeline.js

@@ -116,7 +116,7 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
             channelType: adapter.channelType,
             agentId,
             sessionKey: formatSessionKey(sessionKey),
-            // CR-02: carry the turn's trajectory id so the Verified Learning correction
+            // Carry the turn's trajectory id so the Verified Learning correction
             // writer can record the prior completed trajectory for a single-agent turn
             // off the PAYLOAD (this emit runs outside the executor's runWithContext). The
             // ingress context reuses the trajectory traceId; absent only on non-context
@@ -200,7 +200,7 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
                 traceId: tryGetContext()?.traceId ?? randomUUID(),
                 tenantId: sessionKey.tenantId,
                 userId: sessionKey.userId,
-                // REACT-04 (206-04): stamp the resolved agentId onto the ALS for
+                // Stamp the resolved agentId onto the ALS for
                 // context-consistency with the main execute path (execution-execute.ts).
                 // This branch skips the SEND, but keeping agentId on the context avoids a
                 // divergent ALS shape between the two executor entry points.
@@ -270,11 +270,11 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
     // this turn (after the send-policy gate — denied turns deliver nothing, so
     // they get no coordinator) and subscribe it to the activity stream BEFORE
     // execution so it observes every tool:*/model:* event emitted during the
-    // run. The coordinator is finalized after delivery (gated on the §16.6
+    // run. The coordinator is finalized after delivery (gated on the delivery
     // receipt) and disposed in the finally (aborted/error turns still
     // unsubscribe). Active only when BOTH the stream port and the factory are
     // injected (the daemon composition root supplies them); otherwise the turn
-    // runs exactly as before.
+    // runs without the activity coordinator.
     // ===================================================================
     let coordinator;
     if (deps.activityStreamPort && deps.coordinatorFactory) {
@@ -309,7 +309,7 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
     try {
         if (execResult.timedOut) {
             emitDiagnostic(0, 0, "timeout");
-            // Aborted turn (timeout): the renderer keeps the diagnostic trail (§7.3).
+            // Aborted turn (timeout): the renderer keeps the diagnostic trail.
             await finalizeCoordinator({ kind: "aborted", reason: "timeout" });
             return;
         }
@@ -330,10 +330,10 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
         // Stage 3: Response sanitization, filtering, media, voice, prefix
         const filterResult = await filterExecutionResponse(deps, adapter, effectiveMsg, originalMsg, sessionKey, agentId, execResult.result, execResult.accumulated, replyTo, execResult.resourceAborted, execResult.abortReason, execResult.finishReason);
         if (!filterResult.deliver) {
-            // Nothing reaches the user this turn → a silent outcome (§4.3). "filtered"
+            // Nothing reaches the user this turn → a silent outcome. "filtered"
             // = the model produced no user-visible reply (NO_REPLY); a voice-only
             // delivery or any other non-deliver reason reads as SILENT. The renderer
-            // deletes the transient scaffolding on silent (§7.3).
+            // deletes the transient scaffolding on silent.
             const silentReason = filterResult.reason === "filtered" ? "NO_REPLY" : "SILENT";
             if (filterResult.reason === "filtered") {
                 emitDiagnostic(execResult.tokensUsed, execResult.cost, "filtered");
@@ -353,7 +353,7 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
         // Stage 4: Chunking, coalescing, block pacing, delivery.
         // deliverExecutionResponse now returns a delivery receipt.
         //
-        // REACT-04 (206-04): the delivery runs OUTSIDE the executor's
+        // The delivery runs OUTSIDE the executor's
         // runWithContext (executeLlm returns the text; delivery happens here), so it
         // would otherwise inherit the channel-ingress ALS — which carries NO agentId
         // (context.ts:38: "NOT known at channel ingress"). deliverToChannel reads
@@ -361,7 +361,7 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
         // (b) bind the minted reply id → trajectory (the reaction-attribution
         // keystone). Without agentId on THIS context, ctx.agentId is undefined → the
         // reply's agentId is never recorded and both binding paths fail-closed → a
-        // reaction on the reply map-misses (the 206-03 Stage-C live finding). Wrap
+        // reaction on the reply map-misses. Wrap
         // the delivery in a context that inherits the ingress traceId/tenant/session
         // and ADDS the resolved agentId so the binding fires on the primary path.
         const deliveryReceipt = await runWithContext({
@@ -394,7 +394,7 @@ export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg
                 content: filterResult.text,
             });
         }
-        // Finalize the activity coordinator from the §16.6 delivery receipt.
+        // Finalize the activity coordinator from the delivery receipt.
         // Success → the gate inside finalize defers the renderer's
         // delete until deliveredAtMs; any observed status:"failed" event reclassifies
         // to failure (no delete). A delivery failure receipt → kind:"failure" so the

package/node_modules/@comis/orchestrator/dist/execution/turn-outcome-mapper.d.ts

@@ -6,8 +6,8 @@
  * as a bare "❌ platform". Both are mislabels: no platform error occurred, the
  * run hit a resource limit. This mapper produces a TRUTHFUL
  * kind:"failure" {errorKind:"resource"} carrying a fixed one-line human reason
- * for the resource-abort finish reasons (max_steps / loop_detected), and
- * returns undefined for every other case so the normal
+ * for the resource-abort finish reasons (max_steps / loop_detected /
+ * spend_exceeded), and returns undefined for every other case so the normal
  * success / silent / delivery-failure branches in the pipeline are untouched.
  *
  * Pure: no I/O, no logger, no clock. The reason strings are named constants and
@@ -27,8 +27,9 @@ export interface AbortSignalInput {
  * Map a resource abort to a truthful kind:"failure" TurnOutcome.
  *
  * Returns a failure with errorKind "resource" + a fixed one-line reason for a
- * max_steps / loop_detected abort. Returns `undefined` for any non-resource
- * abort (so the caller's normal branches run): when `resourceAborted` is false,
- * or when the finish reason is not a recognized resource-abort reason.
+ * max_steps / loop_detected / spend_exceeded abort. Returns `undefined` for any
+ * non-resource abort (so the caller's normal branches run): when
+ * `resourceAborted` is false, or when the finish reason is not a recognized
+ * resource-abort reason.
  */
 export declare function mapAbortToTurnOutcome(input: AbortSignalInput): TurnOutcome | undefined;

package/node_modules/@comis/orchestrator/dist/execution/turn-outcome-mapper.js

@@ -2,20 +2,28 @@
 const STEP_LIMIT_REASON = "stopped — hit step limit";
 /** One-line human reason for a repeating-tool loop abort. */
 const LOOP_DETECTED_REASON = "stopped — repeating-tool loop";
+/** One-line human reason for a spend/budget kill (observability.spend ceiling
+ *  or per-root autonomy.budget limb). Without this mapping a spend-aborted turn
+ *  finalized via the success branch and the coordinator's failed-event
+ *  reclassify stamped the status pill with a TRANSIENT recovered tool
+ *  errorKind — a budget stop rendered as "❌ validation". */
+const SPEND_EXCEEDED_REASON = "stopped — spend limit reached";
 /** ErrorKind for any resource abort (step limit / budget / loop). */
 const RESOURCE_ERROR_KIND = "resource";
 /** The finish reasons that map to a truthful resource failure. */
 const RESOURCE_ABORT_REASONS = {
     max_steps: STEP_LIMIT_REASON,
     loop_detected: LOOP_DETECTED_REASON,
+    spend_exceeded: SPEND_EXCEEDED_REASON,
 };
 /**
  * Map a resource abort to a truthful kind:"failure" TurnOutcome.
  *
  * Returns a failure with errorKind "resource" + a fixed one-line reason for a
- * max_steps / loop_detected abort. Returns `undefined` for any non-resource
- * abort (so the caller's normal branches run): when `resourceAborted` is false,
- * or when the finish reason is not a recognized resource-abort reason.
+ * max_steps / loop_detected / spend_exceeded abort. Returns `undefined` for any
+ * non-resource abort (so the caller's normal branches run): when
+ * `resourceAborted` is false, or when the finish reason is not a recognized
+ * resource-abort reason.
  */
 export function mapAbortToTurnOutcome(input) {
     if (!input.resourceAborted)

package/node_modules/@comis/orchestrator/dist/inbound/resolve-and-preprocess.d.ts

@@ -12,8 +12,8 @@ import type { InboundPipelineDeps } from "./inbound-pipeline.js";
 /**
  * Minimal deps for the resolve-and-preprocess phase.
  *
- * Union of the former ResolveDeps (5 fields) + PreprocessDeps (4 fields)
- * with `logger` shared across both sub-phases — 8 unique fields total.
+ * Covers both sub-phases — agent resolution and media preprocessing — with
+ * `logger` shared across both; 8 unique fields total.
  */
 export type ResolveAndPreprocessDeps = Pick<InboundPipelineDeps, "logger" | "eventBus" | "messageRouter" | "sessionManager" | "createExecutor" | "audioPreflight" | "preprocessMessage" | "autoReplyEngineConfig">;
 /** Resolved + preprocessed agent context from Phase 1. */

package/node_modules/@comis/orchestrator/dist/inbound/resolve-and-preprocess.js

@@ -23,7 +23,7 @@ import { isBotMentioned, isGroupMessage, compressAttachments } from "@comis/chan
  * (early exit — message should be dropped; preprocess is not run).
  */
 export async function resolveAndPreprocess(deps, adapter, msg) {
-    // ===== Phase 1A: Agent resolution (from inbound-resolve.ts:53-90) =====
+    // ===== Phase 1A: Agent resolution =====
     // 1. Resolve agent FIRST (only needs RoutableMessage, not SessionKey)
     const agentId = deps.messageRouter.resolve({
         channelType: msg.channelType,
@@ -39,17 +39,22 @@ export async function resolveAndPreprocess(deps, adapter, msg) {
     }
     // 3. senderId is used directly (no cross-platform identity resolution)
     const effectiveMsg = msg;
-    // 4. Build scoped session key (defaults to per-channel-peer DM scope)
+    // 4. Build scoped session key (defaults to per-channel-peer DM scope).
+    //    threadId is sourced from a channel-specific metadata key
+    //    (`msteamsThreadId`) rather than the generic thread extractor, so only
+    //    that channel's threads split into separate sessions — every other
+    //    channel stays at threadId:undefined and keeps a thread-less key.
     const sessionKey = buildScopedSessionKey({
         msg: effectiveMsg,
         agentId,
         adapterChannelId: adapter.channelId,
+        threadId: effectiveMsg.metadata.msteamsThreadId,
     });
     // 5. Emit message:received with the scoped session key
     deps.eventBus.emit("message:received", { message: msg, sessionKey });
     // Load or create session
     deps.sessionManager.loadOrCreate(sessionKey);
-    // ===== Phase 1B: Audio preflight + media preprocessing (from inbound-preprocess.ts:37-114) =====
+    // ===== Phase 1B: Audio preflight + media preprocessing =====
     let processedMsg = effectiveMsg;
     const channelType = adapter.channelType;
     // -------------------------------------------------------------------

package/node_modules/@comis/orchestrator/dist/index.js

@@ -81,7 +81,7 @@ export { buildScopedSessionKey, extractThreadId } from "./session-key/session-ke
 // the announcement batcher coalesces near-simultaneous sub-agent
 // completions; the dead-letter queue persists failed announcement
 // deliveries for later retry. ANNOUNCE_PARENT_TIMEOUT_MS and
-// SubAgentRunnerLogger (formerly daemon-relative imports) are inlined here
+// SubAgentRunnerLogger are inlined here
 // to avoid an orchestrator->daemon back-edge (forbidden per
 // @comis/orchestrator architecture invariants); daemon's
 // `SubAgentRunnerLogger` shape remains structurally compatible with the
@@ -91,7 +91,7 @@ export { buildScopedSessionKey, extractThreadId } from "./session-key/session-ke
 export * from "./cross-session/cross-session-sender.js";
 export * from "./cross-session/announcement-batcher.js";
 export * from "./cross-session/announcement-dead-letter.js";
-// Interactive approval router (Workstream C). The single server-side authority
+// Interactive approval router. The single server-side authority
 // that parses signed button callbacks (lookup-FIRST-then-verify), rejects
 // cross-session + post-resolution replays, and dispatches to ApprovalGate.
 // Channels never import this — they reach signing via the @comis/core primitive.

package/node_modules/@comis/orchestrator/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comis/orchestrator",
   "private": true,
-  "version": "1.0.44",
+  "version": "1.0.46",
   "author": "Moshe Anconina",
   "license": "Apache-2.0",
   "description": "Inbound orchestration: channel-manager lifecycle, inbound pipeline, execute-and-deliver coordination, command queue, message routing",

package/node_modules/@comis/scheduler/dist/cron/cron-expression.js

@@ -22,7 +22,7 @@ export function computeNextRunAtMs(schedule, nowMs) {
         case "in":
             // Deterministic relative one-shot: now + N seconds. No timezone, no
             // wall-clock parse — the whole point is to bypass the absolute-`at` + IANA
-            // conversion that small models get wrong (CRON-IN-01).
+            // conversion that small models get wrong.
             return nowMs + schedule.seconds * 1000;
     }
 }

package/node_modules/@comis/scheduler/dist/cron/cron-scheduler.d.ts

@@ -32,6 +32,14 @@ export interface CronScheduler {
     removeJob(jobId: string): Promise<boolean>;
     /** Return a shallow copy of in-memory job list. */
     getJobs(): CronJob[];
+    /**
+     * Flush the current in-memory job list to the store. Callers that mutate a job
+     * in place (via a {@link getJobs} reference) MUST call this to make the change
+     * durable — otherwise it only persists on the next `tick()` (the next due
+     * fire), and a daemon restart before then LOSES the edit. `cron.update` mutates
+     * in place, so it relies on this (regression: updates were in-memory-only).
+     */
+    persist(): Promise<void>;
     /** Check all jobs for due status and run any overdue ones. */
     runMissedJobs(): Promise<void>;
 }