@sema-agent/core 5.61.0 → 5.63.0

package/dist/core/runner/prepare-task.d.ts

@@ -73,14 +73,24 @@ export declare const USAGE_WINDOW_REAP_MARGIN_MS: number;
 export interface UsageGovernance {
     /** The ledger key this run is governed under — the principal, or the shared global key. */
     readonly key: string;
+    /** Does any governed window carry a MONEY ceiling? Read by the run loop's pricing seats: only a
+     *  cost-governing deployment has to treat an unevaluable price table as unpriced spend. */
+    readonly governsCost: boolean;
     /** Ms the caller must wait before ANY window would admit work again, or `undefined` when none is
      *  exhausted as of `now`. Reads the ledger; propagates a store failure (an unreadable ceiling must not
      *  read as an open one). */
     check(now: number): Promise<number | undefined>;
-    /** Charge whatever of `cumulativeTokens` has not been charged yet. Takes the run's CUMULATIVE total
-     *  rather than a delta so no caller can double-charge by calling twice, and so a caller that skips a
-     *  boundary loses nothing. */
-    commit(cumulativeTokens: number, now: number): Promise<void>;
+    /**
+     * Charge whatever of the run's cumulative spend has not been charged yet. Takes the run's CUMULATIVE
+     * totals rather than deltas so no caller can double-charge by calling twice, and so a caller that skips
+     * a boundary loses nothing.
+     *
+     * `cumulativeCostMicroUsd` is the MONEY half (integer micro-USD, `stats.costMicroUsd`). Pass `undefined`
+     * when the run's spend has no cost figure at all (RB-368's unpriced state) — a deployment governing a
+     * `maxCostUsd` window then REFUSES here rather than charging the fabricated 0 that would let the ceiling
+     * silently stop applying. A token-only deployment ignores the argument entirely.
+     */
+    commit(cumulativeTokens: number, cumulativeCostMicroUsd: number | undefined, now: number): Promise<void>;
 }
 /**
  * design/164 件四 — resolve the moment an env's lifetime EXPIRES (epoch ms), or `undefined` when the env
@@ -133,8 +143,53 @@ export declare function checkpointScopeOf(spec: {
     principal?: string;
 }): string;
 export { resolveCheckpointStore } from "../checkpoint-store.js";
-export { isFableFamilyModelId, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
+export { isFableFamilyModelId, resolveAttachmentsConfig, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
 export { rebaseWorkspacePath, rebaseWorkspacePathAcross } from "./prepare-workspace-restore.js";
+/** See {@link runGuardChain}. */
+export interface GuardChainArgs {
+    /** The post-frontier view the chain starts from. */
+    edited: AgentMessage[];
+    /** The pre-cap counterpart view (arm A's clearSource — RB-212 durable composition seat). */
+    replayed: AgentMessage[];
+    index: OccurrenceIndex;
+    microCompact: PreparedMicroCompact;
+    guardAt: number;
+    charsPerToken: number;
+    offloadStore: import("../tool-result-store.js").ToolResultStore | undefined;
+    sessionId: string;
+    taskId: string;
+    deps: RunnerDeps;
+    trimPressureRef: {
+        droppedMessages: boolean;
+    };
+    recheck: boolean | undefined;
+    signal: AbortSignal | undefined;
+    /** The r7 per-request observation buffer — the chain DROPS it on its early returns (a discarded
+     *  provisional projection must not narrate itself). */
+    pendingProjectionObservations: Array<() => void>;
+}
+export type GuardChainOutcome = {
+    earlyReturn: {
+        messages: AgentMessage[];
+        adoptSessionRebuild?: boolean;
+    };
+} | {
+    working: AgentMessage[];
+    trimmed: AgentMessage[];
+    trimDroppedMessages: boolean;
+};
+/**
+ * design/374 slice 3 — the GUARD CHAIN over one request build (D-7 case-ii transfer table),
+ * module-level per the design/238 body-span bank. design/123 D3: the chain reads the anchored
+ * coordinate re-estimated on the EDITED array (pre-anchor clears don't lower it — deliberately;
+ * trimToBudget doc). The opt-out machine = the pre-374 backstop order byte-identical
+ * (trim as the ordinary second line); otherwise arm A (blocking machine run, only when the
+ * frontier pass is off) → arm B (in-turn forced compaction behind the adopt seam) → arm C (trim,
+ * the disaster-only last resort and this chain's sole `context.trim` emitter). Returns either the
+ * post-chain view for the pipeline tail, or an EARLY hook result the context handler must return
+ * verbatim (arm-B adoption / the r8 dead-turn stand-down).
+ */
+export declare function runGuardChain(args: GuardChainArgs): Promise<GuardChainOutcome>;
 export interface Prepared {
     harness: AgentHarness;
     /** The CONCRETE built-in session (engine-internal: prepare constructs/acquires `StoredSession` itself,
@@ -876,21 +931,38 @@ export interface Prepared {
     trimPressureRef: {
         droppedMessages: boolean;
     };
-    /** design/374 slices 1b/2 — the microCompact machine state this run: the selected clearing
+    /** design/374 slices 1b/2/3 — the microCompact machine state this run: the selected clearing
      *  machine, the cleared-projection ledger (request-view application, durable decisions — see
      *  `context-edit.ts`'s ledger note; per-run in-memory, so durable resume / `resumeAt` rebuilds
      *  start EMPTY by construction), the last request's projection seat (what the provider actually
      *  saw — the MC-R rejection arm computes its candidates and savings on THIS view, never on the
-     *  raw session rebuild), and the MC-R knob. Default machine "legacy" + MC-R off ⇒ the ledger
-     *  never gains an entry and every replay is a same-reference no-op (default bytes unchanged). */
+     *  raw session rebuild), the MC-R knob, and the slice-3 arm-B seat. The explicit opt-out
+     *  (`machine: "legacy"` + MC-R off) ⇒ the ledger never gains an entry and every replay is a
+     *  same-reference no-op (opt-out bytes unchanged). */
     microCompact: PreparedMicroCompact;
 }
 /** See {@link Prepared.microCompact}. */
 export interface PreparedMicroCompact {
-    machine: ContextEditMachine;
+    /** The frontier-machine selection — `"off"` = no proactive frontier clearing (the unified
+     *  machine instead gets its one blocking-point shot, slice-3 arm A). */
+    machine: "off" | ContextEditMachine;
     /** MC-R (design/374 §3.2): one-shot clear-and-retry on a provider input-too-long rejection.
-     *  Default false (X2: lands with the machinery, flips with slice 3). */
+     *  Default true since the slice-3 flip. */
     clearOnRejection: boolean;
+    /** design/374 slice 3 (arm B) — the in-turn forced-compaction seat: runtask wires a closure
+     *  that runs the SAME forced-compaction pass the prompt-too-long recovery uses (gates included)
+     *  and answers whether a compaction landed in the session. The context hook calls it when the
+     *  pre-send estimate breaks the guard budget and then returns `adoptSessionRebuild` so the
+     *  harness adopts the reduced transcript. `signal` is the TURN-scoped abort of the request
+     *  build (r3): a turn interrupt must be able to cut the summary call short instead of waiting
+     *  it out. `anchoredEstimate` is the chain's own trigger coordinate — the seat consults the
+     *  §25.2 anti-thrash floor against it (an ineffective landing must not be repeated per request
+     *  build; the chain's arm C owns the bounded fallback). Unwired (pure-prepare callers) ⇒ arm B
+     *  declines and the chain falls to the trim last resort — same posture as a compaction-disabled
+     *  run. */
+    inTurnCompactionRef: {
+        current?: (signal?: AbortSignal, anchoredEstimate?: number) => Promise<boolean>;
+    };
     ledger: ClearedProjectionLedger;
     projectionRef: {
         current?: {
@@ -1463,8 +1535,8 @@ export interface RunInternals {
      * receive a subagent's live `task_progress` ticks (which otherwise stay in the child's ISOLATED stream). Threaded
      * recursively down the delegation tree (via `ctx.forwardEvent`), so every nested subagent's ticks bubble to the
      * SAME sink. The Runner's ctx wrapper forwards `task_progress` always; when the run's spec sets
-     * `forwardSubagentEvents: true` it ALSO forwards the child's content events (`text_delta` / `reasoning_delta` /
-     * `tool_start` / `tool_end` — the subagent viewing pane, carrying the same UNTRUSTED-RAW/consumer-must-redact
+     * `forwardSubagentEvents: true` it ALSO forwards the child's content events (`text_delta` / `text_end` (#447) /
+     * `reasoning_delta` / `tool_start` / `tool_end` — the subagent viewing pane, carrying the same UNTRUSTED-RAW/consumer-must-redact
      * contract as the main stream's tool events). Either way the child stream is NEVER merged into the parent's
      * MODEL context (this is purely a render channel). Absent unless the deployment opted in.
      */
@@ -1629,6 +1701,35 @@ export interface ResolvedWorkspace {
      *  which `cwd` is a host path a consumer may diff / merge / remove. */
     remote: boolean;
 }
+/**
+ * RB-330 + 5.38 r2 件2 — the SINGLE effective-delegation derivation for a leg, minted once per prepare
+ * and read by EVERY consumer face; two facets, one source:
+ *
+ *  - `isDelegatedChild` — the raw delegation fact, forks included. Trusted internals first; on a
+ *    resume leg where the caller supplied NO delegation fact, the checkpoint's persisted axis
+ *    ({@link import("../checkpoint-store.js").CheckpointState.isDelegatedChild}) stands in — else a
+ *    deps-only `resume(token, outcome, config)` of a parked delegation read `false` at every station:
+ *    persona flip (subagent consent/notes pack dropped), ask refusal texts on the parent-thread arm
+ *    ("wait for the user" in a transcript no user turn ever lands in), and a lifecycle-observer gate
+ *    that never opened. Consumed by `askSourceIdentity` (a fork's refusal posture is the child's) and
+ *    the `hookIdentity` mint.
+ *  - `isNonForkChild` — the fact minus forks, for the authority/context faces: the `loadProjectMemory`
+ *    ctx flag ({@link RunnerDeps.loadProjectMemory} `isSubagent`) and the prompt runtime fact
+ *    `isSubagent` (RB-204's `SUBAGENT_CONSENT_NOTICE` gate). A FORK is excluded on both, deliberately:
+ *    a fork IS the parent continuing (design/110), so it inherits the parent's authority — and, on the
+ *    memory face, the parent's own project context; trimming a fork's CLAUDE.md would hand the
+ *    continuation LESS context than the run it continues. (RB-330 history: the memory face once used
+ *    `parentTaskId !== undefined` alone, which {@link RunInternals.isDelegatedChild}'s own docstring
+ *    forbids — a directly-started workflow's children have no nameable parent.)
+ *
+ * `insideFork` is NOT persisted (the checkpoint's documented honest absence), so on a deps-only resume
+ * a FORK child reads as a plain delegated child on the non-fork facet — the honest residue is written
+ * on the checkpoint field's own list, not papered over with a new persistence axis.
+ */
+export declare function effectiveDelegationFacts(internals: Pick<RunInternals, "isDelegatedChild" | "insideFork"> | undefined, seedIsDelegatedChild: boolean | undefined): {
+    isDelegatedChild: boolean;
+    isNonForkChild: boolean;
+};
 /**
  * From the resumed/active transcript, the batch position of `currentId` (design/45 §4.ter): the tool-call
  * ids of the assistant message that issued it (the batch), and the subset already resolved (executed