@sema-agent/core 5.60.1 → 5.62.0

package/dist/core/runner/prepare-task.js

@@ -95,7 +95,7 @@ import { BINDING_CHECKPOINT_VERSION, mintCheckpointId, mintCheckpointToken, ORG_
 import { boundInputHashOf } from "../canonical-json.js";
 import { countElicitOptIns, deriveWiringManifest, resolveAskSeamForm, resolveDeclaredDurability, resolveElicitSeam, resolveQuestionSeam, resolveSubagentTranscriptTier } from "../wiring-manifest.js";
 import { durableParkGapFor } from "../park-selfcheck.js";
-import { GLOBAL_USAGE_KEY, usageRetryAfterMs } from "../usage-window-store.js";
+import { GLOBAL_USAGE_KEY, usageRetryAfterMs, windowsGovernCost } from "../usage-window-store.js";
 import { deliverEngineNotice } from "../types.js";
 let announcedMaterializeEnvBySink = new WeakMap();
 const announcedMaterializeEnvConsole = new Set();
@@ -228,6 +228,61 @@ const ULTRA_REASONING_TIERS = new Set(["xhigh", "max"]);
 const DEFAULT_RESOURCE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 export const ENV_LIFETIME_SUSPEND_MARGIN_MS = 60_000;
 export const USAGE_WINDOW_REAP_MARGIN_MS = 60 * 60 * 1000;
+function buildUsageGovernance(windows, deps, principal, sessionId) {
+    if (windows === undefined || windows.length === 0)
+        return undefined;
+    const store = deps.usageWindowStore;
+    if (store === undefined) {
+        deps.onError?.(new Error("RunnerDeps.usageWindows is set but INACTIVE: no `usageWindowStore` is wired, so cross-task usage cannot be counted and no window can be enforced. Wire InMemoryUsageWindowStore (process-local) or FileUsageWindowStore (restart-surviving)."), { phase: "config", sessionId });
+        return undefined;
+    }
+    const key = principal || GLOBAL_USAGE_KEY;
+    const governsCost = windowsGovernCost(windows);
+    let chargedTokens = 0;
+    let chargedCostMicroUsd = 0;
+    let announcedCostGap = false;
+    let recordedUnpricedGap = false;
+    return {
+        key,
+        governsCost,
+        async check(now) {
+            const readings = await store.read(key, windows, now);
+            if (!announcedCostGap && readings.some((r) => r.costUnknown === true)) {
+                announcedCostGap = true;
+                deps.onError?.(new Error(`the usage window for ledger key ${JSON.stringify(key)} holds spend that nothing could price, so its maxCostUsd ceiling is being evaluated against a LOWER BOUND until that charge ages out of the window. Price every model this deployment can reach (including degrade targets and the compaction model).`), { phase: "config", sessionId });
+            }
+            return usageRetryAfterMs(readings, windows);
+        },
+        async commit(cumulativeTokens, cumulativeCostMicroUsd, now) {
+            if (!governsCost) {
+                const delta = cumulativeTokens - chargedTokens;
+                if (delta <= 0)
+                    return;
+                await store.charge(key, delta, now, windows);
+                chargedTokens = cumulativeTokens;
+                return;
+            }
+            if (cumulativeCostMicroUsd === undefined) {
+                const tokenDelta = cumulativeTokens - chargedTokens;
+                if (tokenDelta > 0 || !recordedUnpricedGap) {
+                    await store.charge(key, Math.max(0, tokenDelta), now, windows, null);
+                    chargedTokens = Math.max(chargedTokens, cumulativeTokens);
+                    recordedUnpricedGap = true;
+                }
+                const e = new Error("a deployment usage window declares maxCostUsd, but this run's spend has NO cost figure (RB-368 unpriced: a model served without a RunnerDeps.pricing entry or a Model.cost declaration). Refused rather than charged a fabricated 0 — the money ceiling would have silently stopped applying. Price every model this run can reach, or drop maxCostUsd from the window.");
+                e.code = "config.usage_window_unpriced";
+                throw e;
+            }
+            const tokenDelta = cumulativeTokens - chargedTokens;
+            const costDelta = cumulativeCostMicroUsd - chargedCostMicroUsd;
+            if (tokenDelta <= 0 && costDelta <= 0)
+                return;
+            await store.charge(key, Math.max(0, tokenDelta), now, windows, Math.max(0, costDelta));
+            chargedTokens = cumulativeTokens;
+            chargedCostMicroUsd = cumulativeCostMicroUsd;
+        },
+    };
+}
 export function resolveEnvLifetimeExpiry(env, observedAt) {
     const lifetimeMs = env.lifetimeMs;
     if (lifetimeMs === undefined)
@@ -267,7 +322,7 @@ class ParkRefusal extends Error {
     }
 }
 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";
 function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
     const triggerWindow = resolveTriggerWindow(model);
@@ -339,7 +394,7 @@ function publishCommittedSuspend(refs, token, gate, scope, remoteHandle, checkpo
 function hasConversationContent(branch) {
     return branch.some((e) => e.type === "message" || e.type === "custom_message" || e.type === "compaction");
 }
-function effectiveDelegationFacts(internals, seedIsDelegatedChild) {
+export function effectiveDelegationFacts(internals, seedIsDelegatedChild) {
     const isDelegatedChild = internals?.isDelegatedChild !== undefined ? internals.isDelegatedChild === true : seedIsDelegatedChild === true;
     return { isDelegatedChild, isNonForkChild: isDelegatedChild && internals?.insideFork !== true };
 }
@@ -475,20 +530,21 @@ const sanitizePreview = (node, depth = 0) => {
 function resolveApprovalPreview(tools, toolName, args) {
     const t = tools.find((x) => x.name === toolName || (x.aliases?.includes(toolName) ?? false));
     if (t?.approvalPreview === undefined)
-        return undefined;
+        return {};
     try {
         const raw = t.approvalPreview(args);
         if (raw === undefined)
-            return undefined;
+            return {};
         const bytes = JSON.stringify(raw);
         if (bytes === undefined)
-            return undefined;
-        if (bytes.length > 16_384)
-            return { truncated: true, note: `approval preview exceeded 16KiB (${bytes.length} chars serialized)` };
-        return sanitizePreview(raw);
+            return { withheld: "unavailable" };
+        if (bytes.length > 16_384) {
+            return { preview: { truncated: true, note: `approval preview exceeded 16KiB (${bytes.length} chars serialized)` }, withheld: "oversize" };
+        }
+        return { preview: sanitizePreview(raw) };
     }
     catch {
-        return undefined;
+        return { withheld: "unavailable" };
     }
 }
 function inheritedAskRuleEvidence(deps) {
@@ -839,7 +895,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 if (e.type === "task_progress")
                     forwardSink(e);
                 else if (spec.forwardSubagentEvents === true &&
-                    (e.type === "text_delta" || e.type === "reasoning_delta" || e.type === "tool_start" || e.type === "tool_end")) {
+                    (e.type === "text_delta" || e.type === "text_end" || e.type === "reasoning_delta" || e.type === "tool_start" || e.type === "tool_end")) {
                     forwardSink(e);
                 }
             }
@@ -3140,6 +3196,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             if (ask?.requiresRealApproval === true ||
                 ask?.persistedRuleShadowed !== undefined ||
                 ask?.decisionReason === "hook" ||
+                ask?.matchedAskRule !== undefined ||
                 ask?.inheritedUnresolved === true ||
                 ask?.ancestorResolved === true) {
                 return {};
@@ -3550,31 +3607,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 sessionId,
             });
         }
-        const usageGovernance = (() => {
-            if (usageWindows === undefined || usageWindows.length === 0)
-                return undefined;
-            const store = deps.usageWindowStore;
-            if (store === undefined) {
-                deps.onError?.(new Error("RunnerDeps.usageWindows is set but INACTIVE: no `usageWindowStore` is wired, so cross-task usage cannot be counted and no window can be enforced. Wire InMemoryUsageWindowStore (process-local) or FileUsageWindowStore (restart-surviving)."), { phase: "config", sessionId });
-                return undefined;
-            }
-            const key = spec.principal || GLOBAL_USAGE_KEY;
-            const windows = usageWindows;
-            let charged = 0;
-            return {
-                key,
-                async check(now) {
-                    return usageRetryAfterMs(await store.read(key, windows, now));
-                },
-                async commit(cumulativeTokens, now) {
-                    const delta = cumulativeTokens - charged;
-                    if (delta <= 0)
-                        return;
-                    await store.charge(key, delta, now, windows);
-                    charged = cumulativeTokens;
-                },
-            };
-        })();
+        const usageGovernance = buildUsageGovernance(usageWindows, deps, spec.principal, sessionId);
         const platformSuspendArmed = durableSuspendInfraReady && (envLifetimeSuspendAt !== undefined || usageGovernance !== undefined);
         const checkpointStore = resolveCheckpointStore(spec, deps);
         const durableApproval = spec.durableApproval ??
@@ -3667,8 +3700,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     toolCallId: req.toolCallId,
                     args: req.args,
                     ...(() => {
-                        const preview = approvalPreviewOf(req.toolName, req.args);
-                        return preview !== undefined ? { preview } : {};
+                        const p = approvalPreviewOf(req.toolName, req.args);
+                        return { ...(p.preview !== undefined ? { preview: p.preview } : {}), ...(p.withheld !== undefined ? { previewWithheld: p.withheld } : {}) };
                     })(),
                     ...ruleOffersOf(req.toolName, req.args, decision.action === "ask" ? decision : undefined),
                     message: decision.message ?? `approval required for "${req.toolName}"`,
@@ -4148,7 +4181,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
             };
             const suspendAsk = parkLaneArmed && checkpointStore !== undefined
-                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage) => {
+                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule) => {
                     const syncFirstEligible = req.toolName === ASK_USER_QUESTION_TOOL_NAME ? contentAskRoutable(req.toolCallId) : isLiveApproverSeat(onAsk);
                     if (syncFirstEligible &&
                         runtimeCaps?.forceDurableGate !== true &&
@@ -4306,10 +4339,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                 toolName: req.toolName,
                                 args: parkedArgs,
                                 ...(() => {
-                                    const preview = approvalPreviewOf(req.toolName, parkedArgs);
-                                    const bidi = carriesBidiControls(parkedArgs) || carriesBidiControls(preview);
+                                    const p = approvalPreviewOf(req.toolName, parkedArgs);
+                                    const bidi = carriesBidiControls(parkedArgs) || carriesBidiControls(p.preview);
                                     return {
-                                        ...(preview !== undefined ? { preview } : {}),
+                                        ...(p.preview !== undefined ? { preview: p.preview } : {}),
+                                        ...(p.withheld !== undefined ? { previewWithheld: p.withheld } : {}),
                                         ...(bidi ? { hasBidiControls: true } : {}),
                                     };
                                 })(),
@@ -4317,6 +4351,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                     ...(realApproval !== undefined ? { requiresRealApproval: true } : {}),
                                     ...(shadowedRule !== undefined ? { persistedRuleShadowed: shadowedRule } : {}),
                                     ...(askDecisionReason !== undefined ? { decisionReason: askDecisionReason } : {}),
+                                    ...(matchedAskRule !== undefined ? { matchedAskRule } : {}),
                                     ...(inheritedUnavailableAsks.has(req.toolCallId) ? { inheritedUnresolved: true } : {}),
                                     ...(segmentCoverage !== undefined ? { segmentCoverage } : {}),
                                 }),

package/dist/core/runner/runtask.d.ts

@@ -51,6 +51,13 @@ interface ResumeRun {
      *  wake message second), each under its own trusted framing — the old merge-into-the-slot shape
      *  silently DISPLACED the parked (undelivered) supervisor steer. Wake outcomes only. */
     wakeMessage?: Omit<PendingSteerEntry, "seq">;
+    /** design/373 §4.3 (D2) — the userPromptSubmit screen's `additionalContext` for {@link wakeMessage},
+     *  captured at the resume ENTRY (the message is screened once, pre-CAS, on the resuming process's
+     *  hook) and delivered by the drain as the engine's own reminder AHEAD of the wake frame — carrying
+     *  it forward is what keeps the hook single-run (re-screening at the drain would be the double-run
+     *  §4.3-3 reserves for the cross-process parked leg). Present only when a wake message passed a
+     *  screen that supplied context. */
+    wakeMessageHookContext?: string;
     /** Compensation hook (design/45/49): called iff the resumed run fails with `resume.env_failed` (post-CAS
      *  workspace `resumeVM` failed) OR `resume.tool_unavailable` (P-7: the approved tool vanished) — in both
      *  the CAS already consumed the checkpoint but the pending action never ran. `resumeStream` supplies a