@sema-agent/core 5.60.1 → 5.62.0

package/CHANGELOG.md

@@ -1,5 +1,130 @@
 # Changelog
 
+## 5.62.0 — 2026-08-26
+
+### Added
+- **Usage-governance cost arm (#462, ruled form 1)**: `UsageWindow.maxCostUsd` joins `maxTokens` as an
+  independent second axis — either filling first exhausts the window; `freesAt`/`retryAfterMs` shared.
+  The charge seam (`UsageWindowStore.charge` / `chargeUsageRecord`) gains a trailing
+  `costMicroUsd?: number | null` three-state (number / `null` = spent-but-unpriceable / `undefined` =
+  store refuses on a $-governed window: `usage_window.store_cost_unanswered`); ledger rows and readings
+  carry `costMicroUsd`/`costUnknown` (a reading with unknown spend declares its money figure a LOWER
+  bound and the engine announces the gap once per run). Unpriced runs under a $-window refuse loudly:
+  `config.usage_window_unpriced` at the config door (the run's own model) and by name at the accounting
+  point (a mid-run degrade target); malformed pricing tables (NaN / negative / missing base rates)
+  refuse the same way. Token-arm behavior and ledger bytes are unchanged for every existing deployment.
+- **Prose segment-end wire signal (#447)**: additive TaskEvent `text_end { content }` — emitted at the
+  brain's block-close boundary (CC's own segmentation point; CC ships each completed content block as
+  its own unit and has no idle heuristic). `content` is the segment's authoritative full text; absence
+  is honest (a brain that reports no block close ≠ the segment did not end). Subagent viewing panes
+  forward it opt-in. Downstream idle-flush heuristics can retire.
+- **design/373 S3 — the userPromptSubmit entrance screens**: `UserPromptSubmitContext` gains
+  `source` (closed five-value union: objective / steer / resume_message / parked_redelivery, plus
+  `followUp` reserved), `inputId`, and `actor` (detached snapshot). The deployment hook now SCREENS
+  three entrances: live `TaskStream.steer` (chain position: domain → liveness → replay short-circuit →
+  screen → accept; replay identity minted from PRE-screen bytes), resume-message (pre-CAS at the verb —
+  a blocked message burns nothing, the row stays pending, the same token redeems once clear), and
+  parked-steer wake redelivery (blocks withhold THAT frame only, disclosed twice: the new notice
+  `steering.parked_input_blocked` + the entry's `human_input` account value `"blocked"`; siblings
+  deliver, a wake never wedges). Blocks refuse typed `steering.blocked_by_hook` (steer-verb error +
+  CheckpointError, one vocabulary, fail-closed on timeout/cancel/crash). Hook-less deployments are
+  byte-unchanged.
+- **Preview-withheld determinant (#457②, CC 245 anchor)**: `AskRequest.previewWithheld`
+  (`"oversize"` / `"unavailable"`) distinguishes "the tool declares no preview" from "the projection
+  failed / was withheld" on the ask face, the park row, and `CheckpointSummary` — the CC-245 form where
+  an unreviewable edit narrows approval to one-time. `matchedAskRule` now joins the rule-offer
+  exclusion set (sync + park faces).
+- **ScheduleWakeup `noop` seat (#455, CC 245 graduation)**: the schema and prompt carry CC's noop
+  contract verbatim; `noop` is REQUIRED unless `stop: true` (a loud one-round refusal, self-correcting —
+  the CC-245 form); the flag rides `tool_end.structured.noop` for hosts to fold streaks (core carries,
+  never counts). Dynamic loop-tick prompts grow the noop clause; cron templates do not.
+- **Token-countdown lane (RB-318 ruled B)**: `TaskSpec.attachments.totalTokensReminder` (opt-in flag) +
+  `totalTokensReminderMode` (CC's five-mode closed set, default `padded-countdown`) render CC's
+  byte-exact `<total_tokens>N tokens left</total_tokens>` from CALLER-fed coordinates (the same
+  used/ceiling pair the budget gate enforces — core forwards, never estimates; no ceiling ⇒ countdown
+  arms stay silent). The padded arm carries CC's monotonic smoothing floor (the number never jumps
+  backwards). Bad modes refuse `config.attachment_invalid` at the config door.
+
+### Narrowings (named)
+- `<total_tokens>` joins the fenced + disclosed envelope tag tables: untrusted content carrying that
+  spelling is now zero-width-broken (fenced lane) and verbatim external data containing it triggers the
+  reminder disclosure footer — this applies to EVERY deployment, opted into the countdown lane or not
+  (the lane's own byte-identity claim is scoped to the attachment lane; the sanitize/disclosure tables
+  are unconditional defense). `attachmentEnvelopeTags` becomes a two-owner table (skills_listing owns
+  `skills`, total_tokens_reminder owns `total_tokens`) — pins asserting a single owner will red.
+- `text_end` is honest about truncation: the openai / open-responses brains no longer mint a
+  `text_end` for a prose segment cut mid-stream (stall promotion, disconnect, in-band overload
+  degrade) — a truncated segment is not COMPLETE, so the frame is absent (the anthropic form); a
+  stream whose `finish_reason` already arrived still closes its segment. The frame's `content` now
+  carries the same trimmed text the final assistant message holds (one source).
+- Pre-existing behavior restored on one seam: a fresh steer landing in the post-loop teardown window
+  now refuses `steering.not_running` (as before 373 S3) instead of `steering.blocked_by_hook`, and
+  the deployment hook is no longer invoked for an undeliverable input.
+- Scheduler calls omitting `noop` (without `stop`) now refuse loudly (previously accepted silently).
+- Closed-set adds, named: steering error family +`steering.blocked_by_hook` (also a CheckpointError
+  code); `ENGINE_NOTICE_CODES` +`steering.parked_input_blocked` (audience `user`);
+  `HumanInputDelivery` +`"blocked"` (3→4); `FROZEN_TASK_EVENT_TYPES` +`text_end`;
+  `steering_injected.source` +`"total_tokens_reminder"`. Downstream exhaustive switches and closed-set
+  pins over any of these will red — re-pin per the new members.
+
+## 5.61.0 — 2026-08-25
+
+### Added
+- **Injection-priority ladder is LIVE (design/373 S1+S2)**: `now`/`next`/`later` now carry three
+  distinct delivery semantics (CC 2.1.223 form). `next` = the running turn's next boundary (the
+  previous behavior of every frame — byte-identical for `next`); `later` = the run's
+  would-otherwise-stop seat (its own closing turn; non-natural endings re-pend per session, the next
+  run's turn-open delivers); `now` = `next`'s guarantee plus a manufactured boundary. A
+  caller-provenance `TaskStream.steer(text, { priority: "now" })` CUTS the in-flight turn at a
+  reconciled boundary (finished tools keep real results; never-started ones settle as paired
+  `[INTERRUPTED]` results with `details.errorKind: "interrupted_never_started"`; the CC-verbatim
+  interruption marker lands) and the run CONTINUES; every real cut emits the new
+  `task.turn_interrupted` notice (audience `user`) and counts toward `maxTurns`. Interrupt authority
+  is the steer face's alone.
+- `TaskStream.steer` gains `options.priority` (default `"next"`); the replay identity (`inputId`)
+  gains the normalized tier as an axis (same id+text at a different tier ⇒ `steering.duplicate_input_id`).
+- `task_notification` wire events gain an additive `priority` field (live + turn-open lanes; absent =
+  pre-373 producer or tier-unknown park — never read absence as `later`).
+- `isTerminalTaskNotification` package-root export; engine-note backlog cap gains terminal preference
+  (#445): at a full cap an INTERNAL-lane terminal frame displaces the oldest event batch (which parks
+  losslessly) instead of parking behind it — external frames of every status stay ordinary
+  displaceable notes (trust cut at the marking site).
+- Engine-layer seams: per-turn AbortController + `interruptTurn(frame)` (consumption guard; run
+  signal wins), pre-request immediate re-check, final commit point (a frame arriving during the
+  stop-gate await window is served by the same run), `AgentHarness.steer` returns the minted frame.
+- **Product-grade origin folding behind a host-code attestation gate (design/376-C1)**:
+  `freezeConsolidationPlan` grows the attested arm — `proposal.mintExposure: "partitioned"` (closed
+  single-member set; non-members refuse structurally at the commit door) switches the fold from the
+  run-level single value to a per-product committed-exposure re-read over declared inputs (any marked
+  input ⇒ external/derived, all-clean ⇒ no origin); every UN-attested plan — every pre-C1 caller and
+  every foreign minter — keeps the run-level blanket byte-identical. `mintExposurePartitionedPlan`
+  + `LlmConsolidationPlanArm` exported: the exposure-partitioned mint bisects candidates on the
+  engine-minted marked flag (clean arm byte-identical to the historical chain; marked arm mints only
+  at markedCount ≥ 2; a lone marked row stands as its handle row, withheld from every call); the
+  attestation threads verbatim distiller → driver → commit. D-1b two-layer world-movement guard:
+  the engine re-checks every served candidate on four axes (rev moved / left listing / challenge-latch
+  / turned marked) and refuses the whole plan `_stale_snapshot`; the driver's cross-cycle roster guard
+  discards a stale mint cache and settles under the NEW stop reason `mint_invalidated`
+  (closed-set add; committed cycles stand add-only). Plan rows gain `markedProducts` (additive);
+  snapshot gate rows record `markedIds` (additive); the instruction-form gate grows the D-5 three-arm
+  form (attested all-clean products follow C-3's clean arm — default refusal + the
+  `allowInstructionProducts` hatch, a named WIDENING vs the pre-C1 marked-set blanket; a marked-input
+  product keeps the unconditional hard arm).
+
+### BREAKING
+- **B1** — `notify()` frames with `priority: "later"` (INCLUDING the parameterless default) moved
+  from next-boundary delivery to the run's closing seat / the next run's turn-open. Honestly noted:
+  in the flat era `later` was silently inert (no runtime signal said so) — the engine version is the
+  only discriminator. Callers needing boundary delivery must pass `priority: "next"` explicitly.
+- **B2** — `notify(…, { priority: "now" })` is now a typed refusal (`notify.invalid_priority`);
+  previously it delivered with a one-per-run disclosure notice.
+- **B3** — the `task.injection_priority_unimplemented` notice code is RETIRED (catalog + audience row
+  + word table). Consumers must judge ladder support by version, never by the code's absence.
+- Closed-set adds, named: `ENGINE_NOTICE_CODES` +`task.turn_interrupted`; notify error family
+  +`notify.invalid_priority`; consolidation run stop reasons +`mint_invalidated`. Internal producer
+  tiers re-seated: subagent terminal frames ×9 and monitor (both shapes) `later`→`next` (#445
+  ALIGNED), workflow terminals now explicit `next`.
+
 ## 5.60.1 — 2026-08-25
 
 ### Fixed

package/dist/agents/subagent.d.ts

@@ -511,8 +511,10 @@ export interface SubagentToolOptions {
     /**
      * design/115 P3 — background sub-agents (CC `run_in_background`). When set, the tool exposes the
      * `run_in_background` parameter: the call returns an `a*` task_id immediately, the child runs
-     * asynchronously, and completion fires ONE task-notification ("later" priority — CC posture: an agent
-     * completion doesn't derail active work). Poll/stop via TaskOutput/TaskStop. Absent ⇒ synchronous only.
+     * asynchronously, and completion fires ONE task-notification ("next" priority — design/373 §3.7 census
+     * re-seat, upstream-anchored: every background-task terminal is explicitly "next" there; the earlier
+     * "later doesn't derail active work" reading was the flat era's — a completion must reach a busy model
+     * at the boundary, not at the run's closing seat). Poll/stop via TaskOutput/TaskStop. Absent ⇒ synchronous only.
      */
     background?: {
         registry: import("../core/task-registry.js").TaskRegistry;

package/dist/agents/subagent.js

@@ -775,7 +775,7 @@ export function createSubagentResume(deps) {
                 }
                 else if (ownsTerminalFacesRevive) {
                     try {
-                        deps.notify?.(resumeFrame, { priority: "later" });
+                        deps.notify?.(resumeFrame, { priority: "next" });
                     }
                     catch {
                     }
@@ -829,7 +829,7 @@ export function createSubagentResume(deps) {
                             ...(abort.signal.aborted ? {} : { error: msgRevive.slice(0, REPORT_FIELD_MAX) }),
                             ...(!abort.signal.aborted && errCodeReviveReject !== undefined ? { errorCode: errCodeReviveReject } : {}),
                             ...(completionIdRejectRevive !== undefined ? { completionId: completionIdRejectRevive } : {}),
-                        }, { priority: "later" });
+                        }, { priority: "next" });
                 }
                 catch {
                 }
@@ -862,7 +862,7 @@ function parkCompletionNotify(deps) {
                     ...payload,
                     summary: `${payload.summary} (delivered after ${pendingCount} background ${pendingCount === 1 ? "child" : "children"} settled)`,
                 }
-                : payload, { priority: "later" });
+                : payload, { priority: "next" });
         }
         catch {
         }
@@ -2387,7 +2387,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             sessionId: forkedId,
                             resumable: false,
                             ...(completionIdReap !== undefined ? { completionId: completionIdReap } : {}),
-                        }, { priority: "later" }), "subagent.reapTerminalNotify");
+                        }, { priority: "next" }), "subagent.reapTerminalNotify");
                     });
                     if (agentName !== undefined) {
                         recordRosterSpawn(ctx.roster, { name: agentName, agentId: taskId, sessionId: forkedId, toolUseId: ctx.toolCallId, owner: bgOwner, scope: bgScope, ...((typeof childModel === "string" ? resolveModelDisplayLabel(childModel) : childModel?.id) !== undefined ? { model: typeof childModel === "string" ? childModel : childModel?.id } : {}), ...(modelFallback !== undefined ? { modelFallback } : {}), ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}), ...(sessionScopedBg ? { sessionScoped: true } : {}), createdAt: Date.now() }, (err) => opts.onObserverError?.(err, { site: "roster.recordSpawn" }));
@@ -2588,7 +2588,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                     resumable: resumableFork,
                                     usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
                                     ...(completionIdFork !== undefined ? { completionId: completionIdFork } : {}),
-                                }, { priority: "later" });
+                                }, { priority: "next" });
                         }
                         catch {
                         }
@@ -2639,7 +2639,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                     ...(settledBg === "failed" ? { error: msgFork.slice(0, REPORT_FIELD_MAX) } : {}),
                                     ...(settledBg === "failed" && errCodeForkReject !== undefined ? { errorCode: errCodeForkReject } : {}),
                                     ...(completionIdForkReject !== undefined ? { completionId: completionIdForkReject } : {}),
-                                }, { priority: "later" });
+                                }, { priority: "next" });
                         }
                         catch {
                         }
@@ -2967,7 +2967,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         sessionId: bgChildSessionId,
                         resumable: false,
                         ...(completionIdReap !== undefined ? { completionId: completionIdReap } : {}),
-                    }, { priority: "later" }), "subagent.reapTerminalNotify");
+                    }, { priority: "next" }), "subagent.reapTerminalNotify");
                 });
                 const bgDurableProbe = bg.registry.durableAgentRowProbe(taskId);
                 const bgRowConfirmed = async () => (bgDurableProbe ? await bgDurableProbe().catch(() => false) : false);
@@ -3438,7 +3438,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     }
                     else if (ownsTerminalFaces) {
                         try {
-                            notify?.(completionFrame, { priority: "later" });
+                            notify?.(completionFrame, { priority: "next" });
                         }
                         catch {
                         }
@@ -3508,7 +3508,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                 ...(settled === "failed" ? { error: msg.slice(0, REPORT_FIELD_MAX) } : {}),
                                 ...(settled === "failed" && errCodeBgReject !== undefined ? { errorCode: errCodeBgReject } : {}),
                                 ...(completionIdBgReject !== undefined ? { completionId: completionIdBgReject } : {}),
-                            }, { priority: "later" });
+                            }, { priority: "next" });
                     }
                     catch {
                     }

package/dist/brain/open-responses.js

@@ -389,6 +389,7 @@ export function createOpenResponsesBrain(config = {}) {
                         }
                     }
                 };
+                const messageFace = (acc) => acc === degenItem && degenFace === "text" && rep.cut !== undefined ? trimDegenerateTail(acc.text, rep.cut) : acc.text;
                 const closeItem = (index, acc) => {
                     if (acc.closed)
                         return;
@@ -399,7 +400,7 @@ export function createOpenResponsesBrain(config = {}) {
                     }
                     else if (acc.kind === "message") {
                         if (acc.block)
-                            out.push({ type: "text_end", contentIndex: index, content: acc.text, partial: { ...partial } });
+                            out.push({ type: "text_end", contentIndex: index, content: messageFace(acc), partial: { ...partial } });
                     }
                     else {
                         const tc = closeFunctionCall(acc);
@@ -598,7 +599,7 @@ export function createOpenResponsesBrain(config = {}) {
                         }
                         handleFrame(frame);
                     },
-                    finalize() {
+                    finalize(opts) {
                         for (const [index, acc] of [...items.entries()].sort((a, b) => a[0] - b[0])) {
                             if (acc.closed)
                                 continue;
@@ -606,6 +607,10 @@ export function createOpenResponsesBrain(config = {}) {
                                 acc.closed = true;
                                 continue;
                             }
+                            if (acc.kind === "message" && opts?.truncated === true) {
+                                acc.closed = true;
+                                continue;
+                            }
                             closeItem(index, acc);
                         }
                         const finalContent = [];
@@ -626,7 +631,7 @@ export function createOpenResponsesBrain(config = {}) {
                                 });
                             }
                             else if (acc.kind === "message") {
-                                const text = acc === degenItem && degenFace === "text" && rep.cut !== undefined ? trimDegenerateTail(acc.text, rep.cut) : acc.text;
+                                const text = messageFace(acc);
                                 if (text !== "") {
                                     finalContent.push({ type: "text", text });
                                     if (text.trim() !== "")

package/dist/brain/openai.js

@@ -481,15 +481,15 @@ export function createOpenAIBrain(config = {}) {
                             }
                         }
                     },
-                    finalize() {
+                    finalize(opts) {
                         closeThinking();
-                        if (emittedTextStart) {
-                            out.push({ type: "text_end", contentIndex: textIndex, content: accumText, partial: { ...partial } });
+                        const textFace = degenerate && degenFace === "text" && rep.cut !== undefined ? trimDegenerateTail(accumText, rep.cut) : accumText;
+                        if (emittedTextStart && (opts?.truncated !== true || finishReason != null)) {
+                            out.push({ type: "text_end", contentIndex: textIndex, content: textFace, partial: { ...partial } });
                         }
                         const finalContent = [];
                         if (accumReasoning)
                             finalContent.push({ type: "thinking", thinking: accumReasoning });
-                        const textFace = degenerate && degenFace === "text" && rep.cut !== undefined ? trimDegenerateTail(accumText, rep.cut) : accumText;
                         if (textFace)
                             finalContent.push({ type: "text", text: textFace });
                         const toolCalls = [];

package/dist/brain/stream-engine.d.ts

@@ -159,8 +159,19 @@ export interface StreamControls {
 export interface StreamParser {
     /** Handle one raw SSE line (`data: {...}`); parse, emit events, call `ctrl.sawContentToken()` on content. */
     onLine(line: string): void;
-    /** Build + emit the final `done`/`error` message after the stream ends. */
-    finalize(): void;
+    /**
+     * Build + emit the final `done`/`error` message after the stream ends.
+     *
+     * `truncated: true` = this finalize is a design/124 tier-A PROMOTION of a mid-stream failure
+     * (stall / connection cut / in-band overload downgrade): the provider never terminated the
+     * stream, so any still-open prose segment was CUT, not closed. A parser that mints segment-end
+     * frames (`text_end`) must withhold them on this arm — the TaskEvent contract promises the frame
+     * means "the model closed the block" (HONEST ABSENCE otherwise) — while still building the same
+     * final message (the facade stamps `partialFinalized` + the warning on the terminal event).
+     */
+    finalize(opts?: {
+        truncated?: boolean;
+    }): void;
     /**
      * design/124 §0.5-2: introspection for the mid-stream failure tiering. Read directly off the
      * parser's accumulated state (cheap, no side effects):

package/dist/brain/stream-engine.js

@@ -551,7 +551,7 @@ export function runStreamingBrain(args) {
                     start = nl + 1;
                     if (onLineOverloadTierA(line)) {
                         midstreamWarning = INBAND_OVERLOAD_WARNING;
-                        parser.finalize();
+                        parser.finalize({ truncated: true });
                         return;
                     }
                 }
@@ -576,7 +576,7 @@ export function runStreamingBrain(args) {
                 buffer += decoder.decode();
                 if (buffer.trim() && onLineOverloadTierA(buffer))
                     midstreamWarning = INBAND_OVERLOAD_WARNING;
-                parser.finalize();
+                parser.finalize(midstreamWarning !== undefined ? { truncated: true } : undefined);
                 return;
             }
             const snap = parser.snapshot();
@@ -585,7 +585,7 @@ export function runStreamingBrain(args) {
                     failure.kind === "stalled"
                         ? "Response stalled mid-stream. The response above may be incomplete."
                         : "Connection closed mid-response. The response above may be incomplete.";
-                parser.finalize();
+                parser.finalize({ truncated: true });
                 return;
             }
             if (snap.hasCompletedToolCall)