@sema-agent/core 7.51.2 → 7.52.0

package/dist/core/runner/announce-once-ledger.js

@@ -3,6 +3,7 @@ import { egressText } from "../untrusted-egress.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { thrownText } from "../thrown-value.js";
 export const ANNOUNCE_ONCE_MAX_DIGESTS = 200;
+const RUNNER_ANNOUNCED = new WeakMap();
 const DROPPED_TOOL_MODEL_LANE = "mcp_dropped_tools";
 export function announceDigest(lane, text) {
     return createHash("sha256").update(lane).update("\n").update(text).digest("hex");
@@ -13,6 +14,14 @@ export function warningDigest(err) {
     const message = thrownText(err);
     return announceDigest(code, egressText("same-principal", message));
 }
+const MEMORY_MOUNT_ADVISORY = {
+    shared: { label: "Shared memory tools", classification: "shared-memory-not-mounted", tail: "the pair mounts together or not at all" },
+    engine: { label: "Memory tools", classification: "memory-tools-not-mounted", tail: "these tools mount together or not at all" },
+};
+export function announceMemoryNotMounted(sink, sessionId, pair, names, reason) {
+    const p = MEMORY_MOUNT_ADVISORY[pair];
+    sink.onErrorOncePerRunner(new Error(`${p.label} ${names.join("/")} were NOT mounted: ${reason} — ${p.tail}.`), { phase: "config", sessionId, classification: p.classification });
+}
 export function droppedToolDigest(d) {
     return announceDigest(DROPPED_TOOL_MODEL_LANE, `${d.server}\n${d.tool}\n${d.reason}`);
 }
@@ -62,6 +71,19 @@ export async function loadAnnounceOnceLedger(session, checkpointMirror, onError)
             advisories.add(digest);
             dirty = true;
         },
+        onErrorOncePerRunner: (err, ctx) => {
+            if (onError === undefined)
+                return;
+            const digest = warningDigest(err);
+            const told = RUNNER_ANNOUNCED.get(onError) ?? new Set();
+            RUNNER_ANNOUNCED.set(onError, told);
+            if (told.has(digest))
+                return;
+            onError(err, ctx);
+            told.add(digest);
+            if (told.size > ANNOUNCE_ONCE_MAX_DIGESTS)
+                told.delete(told.values().next().value);
+        },
         mcpFailuresToAnnounce: (statuses) => {
             const current = statuses
                 .filter((s) => s.status === "failed")

package/dist/core/runner/assemble-result.d.ts

@@ -67,6 +67,11 @@ export interface Stats {
      *  (so it can't be re-derived from `costMicroUsd` alone). The {@link costBreakdown.compactionMicroUsd}
      *  source. Run-loop internal — not a public `TaskResult.stats` field. */
     compactionMicroUsd?: number;
+    /** The permission classifier's and a mod's model-call cost (micro-USD), accumulated by `recordSideCallUsage`. Folded
+     *  into `costMicroUsd` like compaction, but it STAYS inside {@link costBreakdown.llmRootMicroUsd} (an "of which" line,
+     *  not a partition member). Absent until a call is booked. Run-loop internal — the public figure is
+     *  `costBreakdown.sideCallMicroUsd`. */
+    sideCallMicroUsd?: number;
     /**
      * A thin FINANCE TAXONOMY of the LLM-derived costs the engine actually
      * prices, decomposing the task's spend into report categories (no new persisted structure — derived from
@@ -92,6 +97,10 @@ export interface Stats {
         /** Within-task compaction LLM cost (micro-USD) = the running `compactionMicroUsd` accumulator (the
          *  category Framing-4 missed). This IS part of `costMicroUsd`, so it is subtracted from `llmRoot`. */
         compactionMicroUsd: number;
+        /** Side model-call LLM cost (micro-USD) — the permission classifier's and mods' calls — present once one is booked.
+         *  An "of which" line: it is part of `costMicroUsd` AND of `llmRootMicroUsd` (not subtracted from root), so the
+         *  partition `llmRoot + compaction === costMicroUsd` keeps holding. */
+        sideCallMicroUsd?: number;
     };
 }
 /** The two cumulative budget ceilings a task can trip. Tokens outrank cost when both are

package/dist/core/runner/assemble-result.js

@@ -161,6 +161,7 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
             nestedSubagentMicroUsd,
             memoryConsolidationMicroUsd: 0,
             compactionMicroUsd,
+            ...(stats.sideCallMicroUsd !== undefined ? { sideCallMicroUsd: stats.sideCallMicroUsd } : {}),
         };
     }
     const result = text;
@@ -171,8 +172,9 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
         salvagedOutput = text.trim() || undefined;
     }
     const retryAfterMs = errorCode === "usage.window_exhausted" || errorCode === "memory.admission_required" ? flags.retryAfterMs : undefined;
-    const { compactionMicroUsd: _internalCompaction, ...publicStats } = stats;
+    const { compactionMicroUsd: _internalCompaction, sideCallMicroUsd: _internalSideCall, ...publicStats } = stats;
     void _internalCompaction;
+    void _internalSideCall;
     if (flags.unpricedSpend)
         delete publicStats.costMicroUsd;
     const stampHaltedByUser = haltConsumed(flags.haltConsumption);

package/dist/core/runner/call-hook-stations.d.ts

@@ -8,7 +8,8 @@
  *    the decide that approved it — and the station through `AgentHarness.finalizeToolCall`, the loop's own finalize.
  */
 import type { DocumentContent, ImageContent, TextContent } from "../../internal/llm.js";
-import { type HookEnvCapabilities, type HookInvocationIdentity, type Hooks } from "../hooks.js";
+import { type HookEnvCapabilities, type HookInvocationIdentity } from "../hooks.js";
+import { type LegModBus } from "../mods/stations.js";
 import type { PermissionModeController } from "../mode-policy.js";
 import type { TaskSpec } from "../types.js";
 import type { CwdRef } from "../../tools/fs/fs-shared.js";
@@ -30,32 +31,29 @@ export type ToolResultStation = (e: ToolResultSeatEvent) => Promise<{
     content: Array<TextContent | ImageContent | DocumentContent>;
 } | undefined>;
 export interface ToolResultStationInput {
-    /** borrowed-readonly — the resolved hook record: the two post seats and the failure seat, called through the record. */
-    hooks: Hooks | undefined;
+    /** borrowed-readonly — the leg's mods bus: `classic.PostToolUse` / `classic.PostToolUseFailure` are raised on it, and a
+     *  `classic.PreToolUse` handler arms the station too (its context is drained onto the result here). */
+    modBus: LegModBus;
     /** borrowed-mutable — the blocked/suspended call ids. Writer here: the one-shot `delete`. */
     blockedToolCalls: Set<string>;
-    /** borrowed-readonly — the leg's delta seat: the post seats receive the call's wire name off its current roster. */
+    /** borrowed-readonly — the leg's delta seat: the post events carry the call's wire name off its current roster. */
     toolRosterDeltas: ToolRosterDeltaSeat;
     /** borrowed-mutable — PreToolUse `additionalContext` per call id. Writer here: the one-shot drain (`delete`). */
     preToolContexts: Map<string, string[]>;
-    /** borrowed-readonly — the validated per-prepare hook seat bound. */
-    hookTimeoutMs: number;
-    /** borrowed-readonly — prepare's abort seat; `.signal` bounds the post seats and is the failure seat's interrupt fact. */
+    /** borrowed-readonly — prepare's abort seat; `.signal` is the post events' abort and the failure event's interrupt fact. */
     abortController: {
         readonly signal: AbortSignal;
     };
-    /** borrowed-readonly — the REBOUND spec's `signal` (the failure seat's interrupt fact). */
+    /** borrowed-readonly — the REBOUND spec's `signal` (the failure event's interrupt fact). */
     spec: Pick<TaskSpec, "signal">;
-    /** borrowed-readonly — the hand's live tracked cwd, or undefined; `current` is read per post seat. */
+    /** borrowed-readonly — the hand's live tracked cwd, or undefined; `current` is read per post event. */
     handsCwdRef: CwdRef | undefined;
-    /** borrowed-readonly — the env face the post seats' contexts carry, or undefined. */
+    /** borrowed-readonly — the env face the post events carry, or undefined. */
     hookEnvFace: HookEnvCapabilities | undefined;
-    /** borrowed-readonly — the leg's identity envelope every HookToolContext carries. */
+    /** borrowed-readonly — the leg's identity envelope every post event carries. */
     hookIdentity: HookInvocationIdentity;
-    /** borrowed-readonly — the leg's live permission-mode seat (each context reads `observed`). */
+    /** borrowed-readonly — the leg's live permission-mode seat (each event reads `observed`). */
     permissionMode: PermissionModeController;
-    /** borrowed-readonly — where an expired post seat is reported (the leg's own hook-crash lane). */
-    notifyOwnHookCrash: (err: unknown) => void;
     /** borrowed-readonly — the leg's reminder provenance mark (every hook context line carries it). */
     reminderMark: string;
     /** borrowed-mutable — the leg's settlement seam. Writer here: a carrier whose output a host hook rewrote (`noteHostRewrite`). */
@@ -69,11 +67,11 @@ export declare function createToolResultStation(input: ToolResultStationInput):
 export type ApprovedCallScreen = NonNullable<Prepared["approvedCallScreen"]>;
 export type ApprovedCallVerdict = Awaited<ReturnType<ApprovedCallScreen>>;
 export interface ApprovedCallScreenInput {
-    /** borrowed-readonly — the face the gate screens with (the observational wrapper when declared; the leg's mode on every context). */
-    preToolUse: Hooks["preToolUse"] | undefined;
-    /** borrowed-readonly — the validated per-prepare hook seat bound. */
-    hookTimeoutMs: number;
-    /** borrowed-readonly — prepare's abort seat (the screening seat is abort-ended on it). */
+    /** borrowed-readonly — the leg's mods bus (the re-screen raises `classic.PreToolUse` on it, as the gate does). */
+    modBus: LegModBus;
+    /** borrowed-readonly — the leg's live permission-mode seat (each screening e reads `observed`). */
+    permissionMode: PermissionModeController;
+    /** borrowed-readonly — prepare's abort seat (the screening is abort-ended on it). */
     abortController: {
         readonly signal: AbortSignal;
     };
@@ -83,18 +81,16 @@ export interface ApprovedCallScreenInput {
     hookEnvFace: HookEnvCapabilities | undefined;
     /** borrowed-readonly — the leg's identity envelope. */
     hookIdentity: HookInvocationIdentity;
-    /** borrowed-readonly — the own hook-crash reporter (a crashing or timed-out screening face is reported through it). */
-    notifyOwnHookCrash: (err: unknown) => void;
     /** borrowed-mutable — PreToolUse `additionalContext` per call id. Writer here: `admit`'s stash (the station drains it). */
     preToolContexts: Map<string, string[]>;
 }
 /**
- * The approved call's PreToolUse screening — the gate's own seat, its answer FOLDED UNDER THE DECIDE that approved the
- * call (the decide is the upper bound; the screen can only narrow): a deny, a crash, a silence or a refused answer
- * refuses the call in the live gate's own sentences; an ask is the question the decide already answered — unless it
- * demands a person and the decide was the deployment's policy (the one predicate every resume station holds a decide
- * against); a rewrite is what executes when the decide carried none of its own (the person's bytes are the upper bound);
- * context rides the result. Undefined when no face is wired.
+ * The approved call's PreToolUse screening — the gate's own screening, its answer FOLDED UNDER THE DECIDE that approved
+ * the call (the decide is the upper bound; the screen can only narrow): a deny, a failed or cancelled screening, or a
+ * refused answer refuses the call in the live gate's own sentences; an ask is the question the decide already answered —
+ * unless it demands a person and the decide was the deployment's policy (the one predicate every resume station holds a
+ * decide against); a rewrite is what executes when the decide carried none of its own (the person's bytes are the upper
+ * bound); context rides the result. Undefined when no handler hangs on `classic.PreToolUse`.
  */
 export declare function createApprovedCallScreen(input: ApprovedCallScreenInput): ApprovedCallScreen | undefined;
 /**

package/dist/core/runner/call-hook-stations.js

@@ -1,14 +1,28 @@
-import { createPreToolUseScreening, formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
-import { isEngineRefusal } from "../tool-policy.js";
+import { createPreToolUseScreening, formatHookFeedback } from "../hooks.js";
+import { classicEventBase, dispatchClassic, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
 import { policyCannotAnswer } from "../real-approval.js";
-import { traceHookCrash } from "../gate-crash-trace.js";
-import { createSafeNotifier } from "../safe-notify.js";
 import { rosterToolName } from "../tool-roster.js";
 import { wireOf } from "../tool-name-readings.js";
 import { noteHostRewrite } from "../frame-settlement.js";
+function postToolUseAnswer(answer) {
+    const strings = stringMembersAnswer("classic.PostToolUse", ["additionalContext"])(answer);
+    if (strings !== undefined || typeof answer !== "object" || answer === null)
+        return strings;
+    const out = Reflect.get(answer, "updatedOutput");
+    return out === undefined || Array.isArray(out) ? undefined : "answered a non-array \"updatedOutput\"; it replaces the content array";
+}
+function updatedOutputOf(answer) {
+    if (typeof answer !== "object" || answer === null)
+        return undefined;
+    const out = Reflect.get(answer, "updatedOutput");
+    return Array.isArray(out) ? out.filter(isContentBlock) : undefined;
+}
+function isContentBlock(c) {
+    return typeof c === "object" && c !== null && typeof Reflect.get(c, "type") === "string";
+}
 export function createToolResultStation(input) {
-    const { hooks, blockedToolCalls, toolRosterDeltas, preToolContexts, hookTimeoutMs, abortController, spec, handsCwdRef, hookEnvFace, hookIdentity, permissionMode, notifyOwnHookCrash, reminderMark, frameSettlement } = input;
-    const toolResultStationArmed = Boolean(hooks?.postToolUse || hooks?.preToolUse || hooks?.postToolUseFailure);
+    const { modBus, blockedToolCalls, toolRosterDeltas, preToolContexts, abortController, spec, handsCwdRef, hookEnvFace, hookIdentity, permissionMode, reminderMark, frameSettlement } = input;
+    const toolResultStationArmed = modBus.hasHandlers("classic.PostToolUse") || modBus.hasHandlers("classic.PreToolUse") || modBus.hasHandlers("classic.PostToolUseFailure");
     if (toolResultStationArmed) {
         return async (e) => {
             if (blockedToolCalls.delete(e.toolCallId)) {
@@ -17,16 +31,23 @@ export function createToolResultStation(input) {
             let content = e.content;
             let changed = false;
             const post = { toolName: rosterToolName(toolRosterDeltas.current, e.toolName) };
+            const callFacts = (tool) => ({
+                ...classicEventBase(hookIdentity, permissionMode.observed),
+                tool,
+                tool_use_id: e.toolCallId,
+                input: e.input,
+                ...(handsCwdRef?.current !== undefined ? { cwd: handsCwdRef.current } : {}),
+                ...(hookEnvFace !== undefined ? { env: hookEnvFace } : {}),
+            });
             if (e.isError) {
-                if (hooks?.postToolUseFailure) {
+                if (modBus.hasHandlers("classic.PostToolUseFailure")) {
                     let clonedDetails = e.details;
                     try {
                         clonedDetails = structuredClone(e.details);
                     }
                     catch {
                     }
-                    const failedName = wireOf("hook.postToolUseFailure", post);
-                    const failureSeat = await runHookSeat("postToolUseFailure", { timeoutMs: hookTimeoutMs, signal: abortController.signal }, (sig) => hooks.postToolUseFailure(failedName, e.input, {
+                    const failure = {
                         error: e.content
                             .filter((c) => c.type === "text")
                             .map((c) => c.text)
@@ -34,30 +55,26 @@ export function createToolResultStation(input) {
                         isInterrupt: abortController.signal.aborted || spec.signal?.aborted === true,
                         content: e.content.map((c) => ({ ...c })),
                         details: clonedDetails,
-                    }, { toolCallId: e.toolCallId, toolName: failedName, signal: sig, ...(handsCwdRef?.current !== undefined ? { cwd: handsCwdRef.current } : {}), ...(hookEnvFace !== undefined ? { env: hookEnvFace } : {}), identity: hookIdentity, permissionMode: permissionMode.observed }));
-                    if (failureSeat.expired) {
-                        notifyOwnHookCrash(hookSeatExpiredError("postToolUseFailure", hookTimeoutMs, failureSeat.cause, "the observation was abandoned and its additionalContext dropped; the failure result itself is unchanged"));
-                    }
-                    const patch = failureSeat.expired ? undefined : failureSeat.value;
+                    };
+                    const outcome = await dispatchClassic(modBus, "classic.PostToolUseFailure", { ...callFacts(wireOf("hook.postToolUseFailure", post)), failure }, { signal: abortController.signal, checkAnswer: stringMembersAnswer("classic.PostToolUseFailure", ["additionalContext"]) }).catch(() => undefined);
+                    const patch = outcome?.kind === "answered" ? stringMembersOf(outcome.answer, ["additionalContext"]) : undefined;
                     if (patch?.additionalContext) {
                         content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];
                         changed = true;
                     }
                 }
             }
-            else if (hooks?.postToolUse) {
-                const ranName = wireOf("hook.postToolUse", post);
-                const successSeat = await runHookSeat("postToolUse", { timeoutMs: hookTimeoutMs, signal: abortController.signal }, (sig) => hooks.postToolUse(ranName, e.input, { content: e.content, details: e.details, isError: e.isError }, { toolCallId: e.toolCallId, toolName: ranName, signal: sig, ...(handsCwdRef?.current !== undefined ? { cwd: handsCwdRef.current } : {}), ...(hookEnvFace !== undefined ? { env: hookEnvFace } : {}), identity: hookIdentity, permissionMode: permissionMode.observed }));
-                if (successSeat.expired) {
-                    notifyOwnHookCrash(hookSeatExpiredError("postToolUse", hookTimeoutMs, successSeat.cause, "the seat was abandoned; the tool result is delivered to the model UNMODIFIED (no updatedOutput, no additionalContext)"));
-                }
-                const patch = successSeat.expired ? undefined : successSeat.value;
-                if (patch?.updatedOutput) {
-                    content = patch.updatedOutput;
+            else if (modBus.hasHandlers("classic.PostToolUse")) {
+                const outcome = await dispatchClassic(modBus, "classic.PostToolUse", { ...callFacts(wireOf("hook.postToolUse", post)), output: { content: e.content, details: e.details, isError: e.isError } }, { signal: abortController.signal, checkAnswer: postToolUseAnswer }).catch(() => undefined);
+                const answer = outcome?.kind === "answered" ? outcome.answer : undefined;
+                const updatedOutput = updatedOutputOf(answer);
+                const patch = stringMembersOf(answer, ["additionalContext"]);
+                if (updatedOutput) {
+                    content = updatedOutput;
                     changed = true;
                     noteHostRewrite(frameSettlement, e.toolCallId);
                 }
-                if (patch?.additionalContext) {
+                if (patch.additionalContext) {
                     content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];
                     changed = true;
                 }
@@ -74,27 +91,26 @@ export function createToolResultStation(input) {
     return undefined;
 }
 export function createApprovedCallScreen(input) {
-    const { preToolUse, hookTimeoutMs, abortController, handsCwdRef, hookEnvFace, hookIdentity, notifyOwnHookCrash, preToolContexts } = input;
-    if (preToolUse === undefined)
+    const { modBus, permissionMode, abortController, handsCwdRef, hookEnvFace, hookIdentity, preToolContexts } = input;
+    if (!modBus.hasHandlers("classic.PreToolUse"))
         return undefined;
     return async ({ toolCallId, toolName, args, decidedBy }) => {
-        const notifier = createSafeNotifier();
-        const seatInput = { event: { toolCallId, toolName, input: args }, ...(handsCwdRef !== undefined ? { trackedCwd: () => handsCwdRef.current } : {}), ...(hookEnvFace !== undefined ? { hookEnv: hookEnvFace } : {}), identity: hookIdentity, onHookError: notifyOwnHookCrash, abortSignal: abortController.signal };
-        const screening = createPreToolUseScreening(preToolUse, seatInput, hookTimeoutMs, notifier);
+        const screening = createPreToolUseScreening({
+            event: { toolCallId, toolName, input: {} },
+            modBus,
+            observedPermissionMode: () => permissionMode.observed,
+            ...(handsCwdRef !== undefined ? { trackedCwd: () => handsCwdRef.current } : {}),
+            ...(hookEnvFace !== undefined ? { hookEnv: hookEnvFace } : {}),
+            identity: hookIdentity,
+            abortSignal: abortController.signal,
+        });
+        if (screening === undefined)
+            return { args, admit: () => undefined };
         const subject = `this call to "${toolName}"`;
-        let r;
-        try {
-            const seat = await screening.screen(args);
-            if (seat.expired)
-                return { refused: await screening.unansweredReason(subject, seat.cause) };
-            r = screening.screened(seat.value);
-        }
-        catch (err) {
-            traceHookCrash(seatInput, err, notifier);
-            return { refused: screening.crashReason(subject, err) };
-        }
-        if (r !== undefined && isEngineRefusal(r))
-            return { refused: screening.refusedReason(r) };
+        const screened = await screening.screen(args, subject);
+        if (screened.kind === "refused")
+            return { refused: screened.reason };
+        const r = screened.answer;
         if (r?.action === "deny")
             return { refused: screening.deniedReason(r) };
         if (r !== undefined && policyCannotAnswer(r, decidedBy))

package/dist/core/runner/caller-stop-gate.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The run's ONE caller-stop gate: tripped by every channel through which the run's CALLER asks it to stop — the
+ * `halt()`, `interrupt()` and `destroy()` verbs (`stop()`) and the caller's own `TaskSpec.signal` (composed into
+ * `signal` at the mint) — at any moment until the run publishes its result, the loop's end included. It answers one
+ * question, "did the caller ask this run to stop?", and every compaction pass of the run reads it the same way: a
+ * tripped gate admits no pass, and a pass in flight carries it both as an abort and as its withdrawal signal, so a
+ * stop landing mid-pass cuts the summary call and the pass reports a cancel. It is not an attribution: who OWNS the
+ * run's ending stays on the loop latch's first-writer seats, and an engine stop (a limit, an output retry cap, a
+ * gate) never trips it.
+ *
+ * Minted once per run beside the loop latch and carried on it (`LiveHandle.loop.callerStop`), so the verbs and the
+ * run body hold the same object.
+ */
+export interface CallerStopGate {
+    /** The verbs' write face; idempotent. */
+    stop(): void;
+    /** The read face: aborted once any caller channel fired. */
+    readonly signal: AbortSignal;
+}
+/**
+ * The caller's own signal is COMPOSED into the read face, not listened to: there is nothing to release, so the gate
+ * keeps answering after the leg dropped its own listener on that signal — which is exactly when the end-of-task
+ * pass runs.
+ */
+export declare function mintCallerStopGate(callerSignal: AbortSignal | undefined): CallerStopGate;

package/dist/core/runner/caller-stop-gate.js

@@ -0,0 +1,7 @@
+export function mintCallerStopGate(callerSignal) {
+    const verbs = new AbortController();
+    return {
+        stop: () => verbs.abort(),
+        signal: callerSignal !== undefined ? AbortSignal.any([verbs.signal, callerSignal]) : verbs.signal,
+    };
+}

package/dist/core/runner/compaction-seams.d.ts

@@ -1,5 +1,4 @@
 import type { MaybeCompactOptions } from "../auto-compaction.js";
-import type { TaskSpec } from "../types.js";
 import type { Prepared, RunnerDepsSeat } from "./contracts.js";
 /**
  * The cost-optimization compaction options threaded into BOTH `maybeCompact` call
@@ -13,27 +12,14 @@ import type { Prepared, RunnerDepsSeat } from "./contracts.js";
  * function itself always returns an object.
  */
 export declare function seamCCompactionOptions(runner: RunnerDepsSeat, prepared: Prepared): Pick<MaybeCompactOptions, "summaryProvider" | "onCompaction" | "maxConsecutiveProviderReuse" | "consecutiveProviderReuse" | "onCommitted">;
-/** Resolve the pre/postCompact lifecycle callbacks (whole-slot `spec.hooks ??
- *  deps.hooks`, same resolution as the stop hook) and wrap each in a SWALLOW+TRACE shell before
- *  threading them into maybeCompact. The wrapper owns the observability half of the R3 MED contract
- *  (maybeCompact swallows defensively too, but has no sink): a throwing callback is reported via
- *  `onError(phase:"hook")` and treated as absent; a `block` returned under a "forced" trigger is
- *  reported as ignored (maybeCompact enforces the ignore — blocking a compaction the provider/trim
- *  layer already demanded would kill the run). */
-export declare function compactionHookOptions(runner: RunnerDepsSeat, spec: TaskSpec, sessionId: string, trigger: "auto" | "manual" | "forced", 
-/** The leg's identity envelope, spread onto both compaction contexts by the wrappers
- *  below (the compaction module builds its contexts below the runner and cannot know the leg;
- *  the wrapper is the runner's seam). Every runner call site supplies `prepared.hookIdentity`;
- *  optional only so a context built without a leg stays honestly identity-less. */
-identity?: import("../hooks.js").HookInvocationIdentity, 
-/** The leg's already-validated seat bound (`Prepared.hookTimeoutMs`) and its abort signal. Optional
- *  for the same reason `identity` is — a wrapper built without a prepared leg still works, on the
- *  default bound and with no signal. The signal is what keeps a hung compaction hook from holding a
- *  CANCELLED run's turn boundary for the whole deadline (the seat's post-abort grace). */
-seatBound?: {
-    timeoutMs: number;
-    signal?: AbortSignal;
-}): Pick<MaybeCompactOptions, "trigger" | "preCompact" | "postCompact">;
+/** The pre/postCompact stations threaded into maybeCompact: `classic.PreCompact` and `classic.PostCompact` raised on the
+ *  leg's bus (a station is wired only when a handler hangs on its event). Their failure and abort columns are the
+ *  bus's — a handler that throws or runs past its budget is skipped and reported, so a failed gate is "no block, no
+ *  instructions" and the compaction that was already deemed necessary proceeds. A `block` answered under a "forced"
+ *  trigger is reported as ignored (maybeCompact enforces the ignore — blocking a compaction the provider/trim layer
+ *  already demanded would kill the run). `signal` is the pass's abort (absent ⇒ each handler's own budget is the
+ *  whole bound). */
+export declare function compactionHookOptions(runner: RunnerDepsSeat, prepared: Pick<Prepared, "modBus" | "hookIdentity" | "sessionId">, trigger: "auto" | "manual" | "forced", signal: AbortSignal | undefined): Pick<MaybeCompactOptions, "trigger" | "preCompact" | "postCompact">;
 /** Fold a finished compaction's `reused` flag into the run-scoped consecutive-reuse
  *  counter: a reused (provider) summary increments it, a real (LLM) summary resets it to 0. A no-op
  *  compaction (`compacted:false`) leaves the counter untouched. No-op when no provider is wired. */

package/dist/core/runner/compaction-seams.js

@@ -1,5 +1,4 @@
-import { hookSeatExpiredError, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
-import { asThrownError } from "../thrown-value.js";
+import { classicEventBase, dispatchClassic, observeClassic, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
 export function seamCCompactionOptions(runner, prepared) {
     return {
         ...(runner.deps.summaryProvider
@@ -17,66 +16,42 @@ export function seamCCompactionOptions(runner, prepared) {
         },
     };
 }
-export function compactionHookOptions(runner, spec, sessionId, trigger, identity, seatBound) {
-    const hooks = spec.hooks ?? runner.deps.hooks;
-    const pre = hooks?.preCompact;
-    const post = hooks?.postCompact;
-    const seatMs = seatBound?.timeoutMs ?? resolveHookTimeoutMs(hooks?.timeoutMs);
-    const seatSignal = seatBound?.signal;
-    const withIdentity = (ctx) => identity !== undefined ? { ...ctx, identity } : ctx;
+export function compactionHookOptions(runner, prepared, trigger, signal) {
+    const bus = prepared.modBus;
+    const base = classicEventBase(prepared.hookIdentity);
+    const report = (err) => {
+        try {
+            runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+        }
+        catch {
+        }
+    };
     return {
         trigger,
-        ...(pre
+        ...(bus.hasHandlers("classic.PreCompact")
             ? {
-                preCompact: async (rawCtx) => {
-                    const ctx = withIdentity(rawCtx);
-                    const report = (err) => {
-                        try {
-                            runner.deps.onError?.(err, { phase: "hook", sessionId });
-                        }
-                        catch {
-                        }
-                    };
-                    try {
-                        const seat = await runHookSeat("preCompact", { timeoutMs: seatMs, ...(seatSignal !== undefined ? { signal: seatSignal } : {}) }, (sig) => pre.call(hooks, { ...ctx, signal: sig }));
-                        if (seat.expired) {
-                            report(hookSeatExpiredError("preCompact", seatMs, seat.cause, `the "${ctx.trigger}" compaction PROCEEDED unblocked and with no additional instructions`));
-                            return undefined;
-                        }
-                        const r = seat.value;
-                        if (r?.block && ctx.trigger === "forced") {
-                            report(new Error(`a preCompact callback blocked a "forced" compaction — ignored (PTL/trim-pressure compaction is not optional): ${r.block}`));
-                        }
-                        return r;
-                    }
-                    catch (err) {
-                        report(asThrownError(err));
+                preCompact: async (ctx) => {
+                    const outcome = await dispatchClassic(bus, "classic.PreCompact", { ...base, trigger: ctx.trigger, ...(ctx.customInstructions !== undefined ? { customInstructions: ctx.customInstructions } : {}) }, { ...(signal !== undefined ? { signal } : {}), checkAnswer: stringMembersAnswer("classic.PreCompact", ["block", "additionalInstructions"]) });
+                    if (outcome?.kind !== "answered")
                         return undefined;
+                    const r = stringMembersOf(outcome.answer, ["block", "additionalInstructions"]);
+                    if (r.block && ctx.trigger === "forced") {
+                        report(new Error(`a preCompact handler blocked a "forced" compaction — ignored (PTL/trim-pressure compaction is not optional): ${r.block}`));
                     }
+                    return r;
                 },
             }
             : {}),
-        ...(post
+        ...(bus.hasHandlers("classic.PostCompact")
             ? {
-                postCompact: async (rawCtx) => {
-                    try {
-                        const seat = await runHookSeat("postCompact", { timeoutMs: seatMs, ...(seatSignal !== undefined ? { signal: seatSignal } : {}) }, (sig) => post.call(hooks, { ...withIdentity(rawCtx), signal: sig }));
-                        if (seat.expired) {
-                            try {
-                                runner.deps.onError?.(hookSeatExpiredError("postCompact", seatMs, seat.cause, "the observation was abandoned; the compaction that already landed is unchanged"), { phase: "hook", sessionId });
-                            }
-                            catch {
-                            }
-                        }
-                    }
-                    catch (err) {
-                        try {
-                            runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId });
-                        }
-                        catch {
-                        }
-                    }
-                },
+                postCompact: (ctx) => observeClassic(bus, "classic.PostCompact", {
+                    ...base,
+                    trigger: ctx.trigger,
+                    summary: ctx.summary,
+                    ...(ctx.tokensBefore !== undefined ? { tokensBefore: ctx.tokensBefore } : {}),
+                    ...(ctx.tokensAfter !== undefined ? { tokensAfter: ctx.tokensAfter } : {}),
+                    ...(ctx.freedTokens !== undefined ? { freedTokens: ctx.freedTokens } : {}),
+                }, signal),
             }
             : {}),
     };

package/dist/core/runner/construction-doors.js

@@ -1,8 +1,9 @@
 import { checkedAgentConfigDir } from "../agent-config-dir.js";
 import { checkedMediaByteCap } from "../media-byte-cap.js";
-import { receiveOwnProperties, refuseProxy } from "../own-property-receipt.js";
+import { receiptRefusal, receiveOwnProperties, refuseProxy } from "../own-property-receipt.js";
 import { assertNoRetiredRunnerDeps } from "./retired-runner-deps.js";
 import { copyReadDenySeat, READ_DENY_DEPLOYMENT_SEATS } from "../read-face-seats.js";
+import { holdOwnCredentialValues } from "../secret-env.js";
 export function retainRunnerDeps(deps) {
     const words = { subject: "RunnerDeps", unit: "seat", moment: "at new Runner" };
     refuseProxy(deps, words);
@@ -14,5 +15,14 @@ export function retainRunnerDeps(deps) {
         if (Object.hasOwn(retained, seat))
             Object.defineProperty(retained, seat, { value: copyReadDenySeat(Reflect.get(retained, seat)), enumerable: true, writable: true, configurable: true });
     }
+    let consolidationKey;
+    try {
+        const chat = retained.memoryConsolidationDriver?.chat;
+        consolidationKey = typeof chat === "object" && chat !== null ? Reflect.get(chat, "apiKey") : undefined;
+    }
+    catch {
+        throw receiptRefusal("RunnerDeps.memoryConsolidationDriver.chat threw while its apiKey was read at new Runner — refused (the thrown value is not repeated)");
+    }
+    holdOwnCredentialValues([typeof consolidationKey === "string" ? consolidationKey : undefined], retained.onNotice);
     return retained;
 }