@sema-agent/core 7.55.0 → 7.57.0

package/dist/core/runner/caller-roster.d.ts

@@ -12,7 +12,8 @@
  * (string and symbol keys — what the mount's spread carries) plus every ToolSpec member name read through an ordinary
  * property read (how the phases read a declaration — non-enumerable, inherited or Proxy-answered included), each read once;
  * every declaration value is deep-copied and frozen by the one copier. A primitive is immutable and stays as read. A
- * read that throws refuses the run at the snapshot. Whether the ToolSpec arm can build the entry ({@link specArmCanConstruct})
+ * read that throws refuses the run at the snapshot, and so does an entry that carries a retired ToolSpec member under any
+ * reading of the key ({@link refuseRetiredMember}: the entry is asked once, before any face is minted). Whether the ToolSpec arm can build the entry ({@link specArmCanConstruct})
  * is asked of the entry once, there, and recorded on its face ({@link specArmCanBuild}); the mount refuses an entry it
  * cannot build from that record, so an `execute` that grows on the caller's object later is never read. The mount calls a
  * spec face's `execute` with the caller's own object as `this` ({@link callerEntryOrigin}). A `defineTool` product's face is
@@ -57,16 +58,27 @@ export declare function callerEntryOrigin(entry: object): object;
 /** Can the mount's ToolSpec arm build this roster entry? Only the verdict recorded at the snapshot answers: an object that
  *  is no face of this snapshot, a primitive, a product's face, is not built from. */
 export declare function specArmCanBuild(entry: RosterFace): boolean;
-/** A `TaskSpec.tools` spec declaring an engine contract (a `core.` id) its catalog did not mint for it — the id written by hand — refused where the
- *  declaration enters. An engine definition under any declared name carries the minted object; a host can forge the string, never the object. */
+/** A roster entry claiming an engine contract its catalog did not mint for it — the id written by hand, on a spec or on a product — refused where the
+ *  declaration enters. */
 export declare function callerEngineContractProblem(face: RosterFace): {
     code: ToolDeclarationCode;
     message: string;
 } | undefined;
+/** The retired-key door for one roster entry, asked of the LIVE entry once, before any member is copied: the key is present
+ *  iff ordinary property lookup answers a defined value ({@link retiredKeyOf} — an own enumerable member, a non-enumerable
+ *  one, a prototype's getter, a Proxy's trap alike), and a present one refuses the run by name with the sentence and code
+ *  the factory gives the same key on a `defineTool` spec (`config.deps_retired_key`). A lookup that throws is an entry whose
+ *  members cannot be read, refused as such. No face is ever minted from an entry that carries a retired member, so no later
+ *  phase has a key table of its own to consult for one. Every live object that is about to become a face meets it first:
+ *  {@link rosterFaceOf} asks it of each entry, and the per-task agents rebuild asks it of the object `withAgents` returned
+ *  before the stamp copy-back spreads that object (a spread drops a prototype's and a non-enumerable member). A value that
+ *  is no object holds no member. */
+export declare function refuseRetiredMember(entry: unknown, index: number): void;
 /** One entry of the roster, and the ONLY place a {@link RosterFace} is minted. Every object entry (a function included) becomes a frozen face, so no entry the snapshot holds is a
  *  live object: a primitive is immutable and stays as read; a `defineTool` product's face names the product for its sealed
  *  rebind; an entry the ToolSpec arm cannot build gets a face too, and the mount refuses it from the verdict recorded here —
- *  an `execute` or a mark that grows on the caller's object afterwards is never read. A read that throws refuses the run. */
+ *  an `execute` or a mark that grows on the caller's object afterwards is never read. An entry carrying a retired member is
+ *  refused first ({@link refuseRetiredMember}). A read that throws refuses the run. */
 export declare function rosterFaceOf(t: unknown, index: number): RosterFace;
 /** The mount's arm for a roster entry that is the face of a `defineTool` product: the exact product object is rebound to
  *  the run's ctx through the factory's sealed seat, compared with its face ({@link refuseProductDrift}), and the tool the

package/dist/core/runner/caller-roster.js

@@ -1,7 +1,8 @@
 import { TOOL_SPEC_MEMBERS, frozenExtra, frozenMember, newCopyState } from "../tool-spec-members.js";
+import { RETIRED_TOOL_SPEC_KEYS, retiredKeyOf, retiredKeyRefusal } from "../retired-keys.js";
 import { isDefineToolProduct, rebindDefineToolCtx } from "../tools.js";
 import { isCatalogContract } from "../tool-catalog-entries.js";
-import { contractOriginOf } from "../../prompt-assembly/tool-catalog.js";
+import { attachedContractOf, computeShapeDigest, contractOriginOf, isEngineDescriptor } from "../../prompt-assembly/tool-catalog.js";
 function specArmCanConstruct(t) {
     if (typeof t !== "object" || t === null)
         return false;
@@ -19,6 +20,8 @@ function faceKeys(t) {
     const keys = new Set(Reflect.ownKeys(t).filter((k) => Object.getOwnPropertyDescriptor(t, k)?.enumerable === true));
     for (const name of TOOL_SPEC_MEMBERS)
         keys.add(name);
+    for (const name of Object.keys(RETIRED_TOOL_SPEC_KEYS))
+        keys.delete(name);
     return [...keys];
 }
 const BUILDABLE = new WeakSet();
@@ -45,16 +48,42 @@ function refuseUnreadableEntry(index, entry, cause) {
     e.code = "config.tool_mount_denied";
     throw e;
 }
-const CATALOG_CONTRACT_FACES = new WeakSet();
+function unmintedEngineClaim(face) {
+    const declared = face.contract?.contractId;
+    if (typeof declared === "string" && contractOriginOf(declared) === "core" && !isCatalogContract(face.contract))
+        return declared;
+    const carried = attachedContractOf(face);
+    if (carried === undefined || carried === null || typeof carried !== "object")
+        return undefined;
+    const id = carried.contractId;
+    if (carried.origin !== "core" && !(typeof id === "string" && contractOriginOf(id) === "core"))
+        return undefined;
+    const describesFace = isEngineDescriptor(carried) && carried.wireName === face.name && carried.shapeDigest === computeShapeDigest(face.parameters);
+    return describesFace ? undefined : String(id);
+}
 export function callerEngineContractProblem(face) {
-    const id = face.contract?.contractId;
-    if (typeof id !== "string" || contractOriginOf(id) !== "core" || CATALOG_CONTRACT_FACES.has(face))
+    const id = unmintedEngineClaim(face);
+    if (id === undefined)
         return undefined;
     return { code: "config.tool_face_invalid", message: `tool ${JSON.stringify(String(face.name).slice(0, 40))} declares the engine contract ${JSON.stringify(id.slice(0, 64))}, which no engine definition minted for it — a contract id under \`core.\` belongs to the engine's own definitions; declare an id of your own, or none` };
 }
+export function refuseRetiredMember(entry, index) {
+    if ((typeof entry !== "object" && typeof entry !== "function") || entry === null)
+        return;
+    let hit;
+    try {
+        hit = retiredKeyOf(entry, RETIRED_TOOL_SPEC_KEYS);
+    }
+    catch (cause) {
+        return refuseEntry(index, entry, cause);
+    }
+    if (hit !== undefined)
+        throw retiredKeyRefusal(hit, "ToolSpec");
+}
 export function rosterFaceOf(t, index) {
     if ((typeof t !== "object" && typeof t !== "function") || t === null)
         return t;
+    refuseRetiredMember(t, index);
     try {
         const product = isDefineToolProduct(t) ? t : undefined;
         const buildable = product === undefined && specArmCanConstruct(t);
@@ -67,8 +96,6 @@ export function rosterFaceOf(t, index) {
             if (value === undefined && !own)
                 continue;
             let kept;
-            if (key === "contract" && isCatalogContract(value))
-                CATALOG_CONTRACT_FACES.add(face);
             if (typeof key === "string" && IS_MEMBER.has(key))
                 kept = frozenMember(key, value, ledger);
             else {

package/dist/core/runner/capability-withheld-seat.d.ts

@@ -0,0 +1,5 @@
+import type { Prepared } from "./contracts.js";
+import type { NoticeSeatInput } from "./notice-seat-input.js";
+/** The session's announced record and the leg's receipt ledger (the parked write). */
+export type CapabilityWithheldRecord = Pick<Prepared, "announcedListingsRef" | "frameReceipts">;
+export declare function createCapabilityWithheldScope(ids: NoticeSeatInput, announced: CapabilityWithheldRecord): <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/core/runner/capability-withheld-seat.js

@@ -0,0 +1,24 @@
+import { runWithCapabilityWithheld } from "../../brain/status-sink.js";
+import { deliverEngineNotice } from "../engine-notice.js";
+import { announceDigest, withAnnounceDigests } from "./announce-once-ledger.js";
+const CAPABILITY_DOWNGRADED = "model.capability_downgraded";
+export function createCapabilityWithheldScope(ids, announced) {
+    const announce = (report) => {
+        const digest = announceDigest(CAPABILITY_DOWNGRADED, `${report.modelId}\n${report.capability}`);
+        const record = announced.announcedListingsRef;
+        if (record.advisories?.includes(digest) === true)
+            return;
+        const why = report.cause === "declared_off"
+            ? `its catalog entry declares no image input (Model.input has no "image")`
+            : `its catalog entry does not declare image input, and images are not sent to an entry that does not`;
+        deliverEngineNotice(ids.onNotice, {
+            code: CAPABILITY_DOWNGRADED,
+            message: `Images in this conversation are not being sent to model "${report.modelId}": ${why}, so each image reaches the model as a one-line placeholder. ` +
+                `If the model reads images, declare it (input: ["text","image"]); otherwise switch to a model that reads images. Said once per conversation for this model.`,
+            detail: { model: report.modelId, capability: report.capability, status: report.cause, sessionId: ids.sessionId, runId: ids.runId },
+        });
+        record.advisories = withAnnounceDigests(record.advisories, [digest]);
+        announced.frameReceipts.listingSnapshotOwed = true;
+    };
+    return (fn) => runWithCapabilityWithheld(announce, fn);
+}

package/dist/core/runner/classifier-ladder.d.ts

@@ -179,14 +179,11 @@ export interface ClassifierUnavailableStation {
     budgetMs?: number;
 }
 /**
- * The classifier's REASONING SEAT, read off the model a classification is actually asked on — ONE predicate:
- * does the wire SPELL off ({@link thinkingOffSpelled})? Yes ⇒ `off` + the verdict-sized cap (the request pays
- * for the answer alone); no ⇒ `low` + the verdict cap + the low allowance (a model whose thinking the wire
- * cannot turn off is asked for the least it can grade, in the room that costs — spell off,
- * or leave thinking to the provider and pay 2048). A model that declares no reasoning at all is on the `low`
- * seat too: its wire carries nothing either way, so the request is the gateway's default, and a default-on
- * gateway thinks — the arm that used to read it as "never thinks" is the one the field report was about.
- * PER RUNG, not once per arming: the second rung is a different model with its own wire.
+ * The classifier's REASONING SEATS, read off the model a classification is actually asked on. The tier is the shared
+ * verdict ({@link lowestReasoningSeat}); the cap is the classifier's own: `off` carries the verdict-sized cap (the
+ * request pays for the answer alone), `low` carries the verdict cap plus the low allowance (spell off, or leave
+ * thinking to the provider and pay 2048). PER RUNG, not once per arming: the second rung is a different model with
+ * its own wire.
  *
  * The THINK seat is the RE-ASK seat ({@link classifierReplyAsksAgain}): a first attempt that produced no
  * verdict is asked once more with thinking allowed the room of CC's stage-2 classifier (8192) — an unknown
@@ -212,7 +209,8 @@ export type ClassifierSeatRequest = typeof CLASSIFIER_OFF_SEAT | typeof CLASSIFI
  * bound the engine can vouch for: a gateway may exclude reasoning tokens from `max_tokens` (a vLLM-fronted
  * Qwen gateway answered a cap of 128 with 938 output tokens and `stop`), so an over-long think is cut by the
  * round-trip timeout (`unavailable` / `timeout`), not by the cap (`parse_error` on an empty reply), and the
- * two are attested as the two different facts they are.
+ * two are attested as the two different facts they are. The seat's tier is not the classifier's to decide: it reads
+ * {@link lowestReasoningSeat}, and only the cap is its own.
  */
 export declare function classifierRungSeat(model: Model): typeof CLASSIFIER_OFF_SEAT | typeof CLASSIFIER_LOW_SEAT;
 /**

package/dist/core/runner/classifier-ladder.js

@@ -1,5 +1,5 @@
 import { sameRouteIdentity } from "../../brain/route-adjudicator.js";
-import { thinkingOffSpelled } from "../../brain/reasoning.js";
+import { lowestReasoningSeat } from "../../brain/reasoning-request.js";
 import { AUTO_MODE_CLASSIFIER_CONTRACT_BROKEN_AFTER, AUTO_MODE_CLASSIFIER_LOW_REASONING_BUDGET_TOKENS, AUTO_MODE_CLASSIFIER_MAX_TOKENS, AUTO_MODE_CLASSIFIER_THINK_BUDGET_TOKENS } from "../auto-mode-defaults.js";
 import { autoModeClassifierFallbackOf, parseAutoModeResponse } from "../auto-mode.js";
 import { classifierUnavailableDispositionOf } from "../classifier-unavailable-arm.js";
@@ -80,7 +80,7 @@ export function announceClassifierRoleDefaulted(args) {
     const { seat } = args;
     if (seat.defaulted === undefined)
         return;
-    const spelled = thinkingOffSpelled(seat.model);
+    const spelled = lowestReasoningSeat(seat.model) === "off";
     deliverEngineNotice(args.onNotice, {
         code: "classifier.role_defaulted",
         message: `no classifier role names a model — "${seat.model.id}" classifies this run (${seat.defaulted}); ` +
@@ -195,7 +195,7 @@ export const CLASSIFIER_OFF_SEAT = { reasoning: "off", maxTokens: AUTO_MODE_CLAS
 export const CLASSIFIER_LOW_SEAT = { reasoning: "low", maxTokens: AUTO_MODE_CLASSIFIER_MAX_TOKENS + AUTO_MODE_CLASSIFIER_LOW_REASONING_BUDGET_TOKENS };
 export const CLASSIFIER_THINK_SEAT = { reasoning: "low", maxTokens: AUTO_MODE_CLASSIFIER_MAX_TOKENS + AUTO_MODE_CLASSIFIER_THINK_BUDGET_TOKENS };
 export function classifierRungSeat(model) {
-    return thinkingOffSpelled(model) ? CLASSIFIER_OFF_SEAT : CLASSIFIER_LOW_SEAT;
+    return lowestReasoningSeat(model) === "off" ? CLASSIFIER_OFF_SEAT : CLASSIFIER_LOW_SEAT;
 }
 export const CLASSIFIER_ATTEMPT_SUFFIX = {
     first: '\nErr on the side of blocking. Your ENTIRE response MUST begin with <block>. Do NOT output any analysis, reasoning, or commentary before <block>. No "Looking at..." or similar preamble.',

package/dist/core/runner/compact-session.d.ts

@@ -0,0 +1,10 @@
+import { type CompactSessionRequest, type CompactSessionResult } from "../auto-compaction.js";
+import { type SessionStore } from "../session.js";
+import type { RunnerDeps } from "../types.js";
+import { type SessionLockSeats } from "./session-verb-doors.js";
+/** What the Runner lends the compaction: its current deps, its session store, and its lock. */
+export interface CompactSessionSeats extends SessionLockSeats {
+    deps: RunnerDeps;
+    sessions: SessionStore;
+}
+export declare function compactIdleSession(seats: CompactSessionSeats, request: CompactSessionRequest): Promise<CompactSessionResult>;

package/dist/core/runner/compact-session.js

@@ -0,0 +1,202 @@
+import { convertToLlm, uuidv7 } from "../../internal/harness.js";
+import { compactionFailureReason, compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, manualCompactOutcomeOf, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
+import { contextOverlayFor } from "../context-settings.js";
+import { admitLegMods, legFacadeSeats } from "../mods/stations.js";
+import { malformedPricingField } from "../pricing.js";
+import { resolveTaskModel } from "../roles.js";
+import { StoredSession } from "../session.js";
+import { emitTrace } from "../trace.js";
+import { egressThrownText } from "../untrusted-egress.js";
+import { emitInputTruncated, legCompactionSettings } from "./compaction-call-options.js";
+import { compactionHookOptions, summaryProviderOptions } from "./compaction-seams.js";
+import { compactionSummaryFallback, compactionSummaryIsDerived } from "./derived-route-fallback.js";
+import { resolveCompactionModel } from "./prepare-config-doors.js";
+import { compactionActivationSnapshot } from "./prepare-tool-disclosure-mount.js";
+import { derivedLegBrain, sideCallBookOf } from "./side-call-account.js";
+import { acquireExistingSession, claimIdleSession, readPlainRequest, shownValue } from "./session-verb-doors.js";
+const VERB = "Runner.compactSession";
+const REQUEST_KEYS = new Set(["sessionId", "model", "instructions", "compaction", "compactionModel", "getApiKeyAndHeaders", "signal"]);
+const SETTINGS_KEYS = new Set(["enabled", "reserveTokens", "keepRecentTokens", "instructions", "clampTolerance"]);
+export async function compactIdleSession(seats, request) {
+    const req = screenCompactSessionRequest(request);
+    const { deps } = seats;
+    const resolved = resolveTaskModel({ model: req.model }, deps);
+    const named = resolveCompactionModel(req.compactionModel !== undefined ? { compactionModel: req.compactionModel } : {}, deps, "compactSession.compactionModel");
+    if (req.signal?.aborted === true)
+        return { outcome: "mooted", events: [] };
+    const release = await claimIdleSession(seats, req.sessionId, () => sessionBusyRefusal(req.sessionId));
+    try {
+        const acquired = await acquireExistingSession(seats.sessions, req.sessionId, VERB, "nothing was compacted");
+        const legMods = await admitLegMods({ spec: {}, deps, sessionId: req.sessionId });
+        return await compactOnSession(req, deps, new StoredSession(acquired.session.getStorage()), resolved, named, legMods);
+    }
+    finally {
+        release();
+    }
+}
+async function compactOnSession(req, deps, session, resolved, named, legMods) {
+    const { sessionId } = req;
+    const events = [];
+    const ident = () => ({ eventId: uuidv7() });
+    const passReport = compactionPassReport({ push: (e) => events.push(e) }, ident);
+    const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
+    const telemetry = { unpricedSpend: false, tracer: deps.tracer, taskId: sessionId };
+    const accountBook = sideCallBookOf(stats, { telemetry, pricing: () => deps.pricing, noteUnevaluablePriceTable: (p) => void (malformedPricingField(p) !== undefined && (telemetry.unpricedSpend = true)), catalog: deps.models });
+    let calls = 0;
+    const book = (lane, model, reply) => {
+        calls += 1;
+        accountBook(lane, model, reply);
+    };
+    const answer = (outcome) => ({
+        outcome,
+        events,
+        ...(calls > 0
+            ? {
+                usage: {
+                    tokens: stats.tokens,
+                    totalInputTokens: stats.totalInputTokens,
+                    promptTokens: stats.promptTokens,
+                    cachedTokens: stats.cachedTokens,
+                    cacheWriteTokens: stats.cacheWriteTokens,
+                    outputTokens: stats.outputTokens,
+                    costMicroUsd: stats.costMicroUsd,
+                    ...(stats.usageMissing === true ? { usageMissing: true } : {}),
+                    ...(telemetry.unpricedSpend ? { unpriced: true } : {}),
+                },
+            }
+            : {}),
+    });
+    const trace = deps.tracer;
+    try {
+        const compactionModel = compactionSummaryIsDerived(req.compactionModel !== undefined, named) ? await compactionSummaryFallback({ derived: named, primary: resolved.model, brain: deps.brain, getApiKeyAndHeaders: req.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId }) : named;
+        const branch = await session.getBranch();
+        const contextMessages = convertToLlm((await session.buildContext()).messages);
+        bindSessionFacade(legMods, { deps, req, model: resolved.model, messages: contextMessages, book });
+        const overlay = contextOverlayFor(deps.contextSettings, resolved.modelRef, deps);
+        const activeTools = compactionActivationSnapshot(branch);
+        const thinking = resolved.thinking ?? resolved.model.defaultThinking;
+        const comp = await maybeCompact({
+            session,
+            model: resolved.model,
+            ...(overlay !== undefined ? { contextOverlay: overlay } : {}),
+            ...(compactionModel !== undefined ? { compactionModel } : {}),
+            brain: derivedLegBrain(() => deps.brain, "compaction", book),
+            ...(req.getApiKeyAndHeaders !== undefined ? { getApiKeyAndHeaders: req.getApiKeyAndHeaders } : {}),
+            ...(thinking !== undefined ? { thinking } : {}),
+            settings: legCompactionSettings(req.compaction !== undefined ? { compaction: req.compaction } : {}, overlay),
+            customInstructions: req.instructions ?? req.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+            ...(req.signal !== undefined ? { signal: req.signal, manualCancelSignal: req.signal } : {}),
+            minTokens: 0,
+            force: true,
+            onInputTruncated: emitInputTruncated(trace, sessionId),
+            ...(activeTools.length > 0 ? { activeTools } : {}),
+            ...summaryProviderOptions({ deps }, 0),
+            ...compactionHookOptions({ deps }, { modBus: legMods.bus, hookIdentity: undefined, sessionId }, "manual", req.signal),
+            onStarted: passReport.onStarted,
+        });
+        const outcome = manualCompactOutcomeOf(comp);
+        if (comp.compacted) {
+            events.push(mintCompactedEvent(comp, "manual", ident()));
+            return answer(outcome);
+        }
+        if (comp.blocked)
+            emitTrace(trace, () => ({ kind: "compaction.blocked", version: 1, taskId: sessionId, trigger: "manual", ts: Date.now() }));
+        else if (comp.disabled)
+            emitTrace(trace, () => ({ kind: "compaction.disabled", version: 1, taskId: sessionId, ts: Date.now() }));
+        else
+            emitTrace(trace, () => ({ kind: "compaction.noop", version: 1, taskId: sessionId, ts: Date.now() }));
+        events.push({ type: "compaction_outcome", outcome: outcome, trigger: "manual", ...ident() });
+        return answer(outcome);
+    }
+    catch (err) {
+        if (isCompactionManualCancel(err)) {
+            emitTrace(trace, () => ({ kind: "compaction.mooted", version: 1, taskId: sessionId, reason: "cancelled", ts: Date.now() }));
+            events.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "cancelled", ...passReport.end, ...ident() });
+            return answer("mooted");
+        }
+        deps.onError?.(asError(err), { phase: "compaction", sessionId });
+        const reason = compactionFailureReason(err);
+        emitTrace(trace, () => ({ kind: "compaction.failed", version: 1, taskId: sessionId, trigger: "manual", reason, ts: Date.now() }));
+        events.push({ type: "compaction_outcome", outcome: "failed", trigger: "manual", reason, ...passReport.end, ...ident() });
+        return answer("failed");
+    }
+}
+function bindSessionFacade(legMods, input) {
+    const unavailable = (method) => {
+        throw new Error(`${method}: not available on a session-level compaction (${VERB}) — there is no run, so no execution environment, working directory, tool roster or agent listing`);
+    };
+    const seats = legFacadeSeats({
+        deps: input.deps,
+        spec: input.req.getApiKeyAndHeaders !== undefined ? { getApiKeyAndHeaders: input.req.getApiKeyAndHeaders } : {},
+        sessionId: input.req.sessionId,
+        model: input.model,
+        executionEnv: { exec: () => unavailable("process.run") },
+        taskRoot: "",
+        cwdRef: undefined,
+        lastBrainContext: () => ({ messages: input.messages }),
+        activeTools: new Set(),
+        agentListing: undefined,
+        book: (answeredBy, reply) => input.book("mod", answeredBy, reply),
+        toolCall: () => unavailable("tool.call"),
+    });
+    legMods.bindFacade({
+        ...seats,
+        cwd: () => unavailable("session.cwd"),
+        root: () => unavailable("session.root"),
+        tools: () => unavailable("tool.list"),
+        agents: () => unavailable("agent.list"),
+    });
+}
+function asError(err) {
+    return err instanceof Error ? err : new Error(egressThrownText("same-principal", err));
+}
+function screenCompactSessionRequest(request) {
+    const bad = (what) => {
+        const e = new Error(`${VERB}: ${what} — nothing was compacted. The request is { sessionId, model, instructions?, compaction?, compactionModel?, getApiKeyAndHeaders?, signal? }.`);
+        e.code = "compact.invalid_request";
+        throw e;
+    };
+    const { sessionId, model, instructions, compaction, compactionModel, getApiKeyAndHeaders, signal } = readPlainRequest(request, REQUEST_KEYS, bad);
+    if (typeof sessionId !== "string" || sessionId === "")
+        return bad(`sessionId must be a non-empty string, got ${shownValue(sessionId)}`);
+    if (model === undefined)
+        return bad("model is required — the model the session's next turn runs on, whose window bounds the pass");
+    if (instructions !== undefined && typeof instructions !== "string")
+        return bad(`instructions must be a string when given, got ${shownValue(instructions)}`);
+    if (getApiKeyAndHeaders !== undefined && typeof getApiKeyAndHeaders !== "function")
+        return bad(`getApiKeyAndHeaders must be a function when given, got ${shownValue(getApiKeyAndHeaders)}`);
+    if (signal !== undefined && !(signal instanceof AbortSignal))
+        return bad(`signal must be an AbortSignal when given, got ${shownValue(signal)}`);
+    return {
+        sessionId,
+        model: model,
+        instructions,
+        compaction: compaction === undefined ? undefined : screenSettings(compaction, bad),
+        compactionModel: compactionModel,
+        getApiKeyAndHeaders: getApiKeyAndHeaders,
+        signal,
+    };
+}
+function screenSettings(raw, bad) {
+    const { enabled, reserveTokens, keepRecentTokens, instructions, clampTolerance } = readPlainRequest(raw, SETTINGS_KEYS, (what) => bad(`compaction: ${what}`));
+    if (enabled !== undefined && typeof enabled !== "boolean")
+        return bad(`compaction.enabled must be a boolean when given, got ${shownValue(enabled)}`);
+    for (const [name, v] of [["reserveTokens", reserveTokens], ["keepRecentTokens", keepRecentTokens], ["clampTolerance", clampTolerance]]) {
+        if (v !== undefined && typeof v !== "number")
+            return bad(`compaction.${name} must be a number when given, got ${shownValue(v)}`);
+    }
+    if (instructions !== undefined && typeof instructions !== "string")
+        return bad(`compaction.instructions must be a string when given, got ${shownValue(instructions)}`);
+    return {
+        ...(enabled !== undefined ? { enabled: enabled } : {}),
+        ...(reserveTokens !== undefined ? { reserveTokens: reserveTokens } : {}),
+        ...(keepRecentTokens !== undefined ? { keepRecentTokens: keepRecentTokens } : {}),
+        ...(instructions !== undefined ? { instructions: instructions } : {}),
+        ...(clampTolerance !== undefined ? { clampTolerance: clampTolerance } : {}),
+    };
+}
+function sessionBusyRefusal(sessionId) {
+    const e = new Error(`${VERB}: a task is running or queued on session "${sessionId}" in this Runner, or a write one of its tasks issued has not settled — compacting it now would rewrite the transcript under that work, so nothing was compacted; a running task takes the request through its own stream (TaskStream.compact), otherwise retry once it has ended and its writes have settled`);
+    e.code = "compact.session_busy";
+    return e;
+}

package/dist/core/runner/compaction-call-options.d.ts

@@ -156,7 +156,7 @@ export declare function emitInputTruncated(tracer: TracerHook | undefined, taskI
  */
 export declare function legContextOverlayOption(prepared: Prepared, runner: RunnerDepsSeat): Pick<MaybeCompactOptions, "contextOverlay">;
 /**
- * The compaction SETTINGS a pass runs under — the assembly all three lanes share.
+ * The compaction SETTINGS a pass runs under — the assembly all three lanes and the out-of-run `Runner.compactSession` share.
  *
  * `{ ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction }` was hand-copied at each lane, and it is where the
  * deployment's live `enabled` declaration belongs: `maybeCompact` has exactly one enablement gate (it reads
@@ -165,4 +165,4 @@ export declare function legContextOverlayOption(prepared: Prepared, runner: Runn
  * compaction runs" a single expression ({@link compactionEnabled}: the request authored it > the deployment
  * declared it > on).
  */
-export declare function legCompactionSettings(spec: TaskSpec, overlay: ContextWindowOverlay | undefined): CompactionSettings;
+export declare function legCompactionSettings(spec: Pick<TaskSpec, "compaction">, overlay: ContextWindowOverlay | undefined): CompactionSettings;

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

@@ -1,4 +1,15 @@
+/**
+ * The run loop's COMPACTION SEAMS, verbatim from three private methods of `Runner`: the Seam C
+ * cost-optimization options every `maybeCompact` call site spreads, the pre/postCompact hook-option wrapper and
+ * the consecutive-reuse counter fold. Layer-1 machinery under a name of its own (the S1 reading: a module the lanes stand
+ * on is not a lane) — the turn-boundary lane, the recovery lane and the terminal adoption's end-of-task pass reach DOWN
+ * for these three where the driver used to hand each lane the methods as delegates on its Input. Every function reads
+ * the Runner's deps LIVE through {@link RunnerDepsSeat}: `runner.deps.x` here is exactly `this.deps.x` in the method it
+ * came from, on the tick it is read.
+ */
+import type { HookInvocationIdentity } from "../hooks.js";
 import type { MaybeCompactOptions } from "../auto-compaction.js";
+import { type LegModBus } from "../mods/stations.js";
 import type { Prepared, RunnerDepsSeat } from "./contracts.js";
 /**
  * The cost-optimization compaction options threaded into BOTH `maybeCompact` call
@@ -12,6 +23,11 @@ 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">;
+/** The Seam C PROVIDER half — the deployment's summary provider, its observer and its drift guard, fed the caller's
+ *  consecutive-reuse count (a run's counter; `0` for a pass outside a run, which has no earlier reuse to count). Still
+ *  provider-gated: with no provider wired the four keys stay ABSENT, so every caller spreads exactly what it spread
+ *  before. */
+export declare function summaryProviderOptions(runner: RunnerDepsSeat, consecutive: number): Pick<MaybeCompactOptions, "summaryProvider" | "onCompaction" | "maxConsecutiveProviderReuse" | "consecutiveProviderReuse">;
 /** 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
@@ -19,7 +35,11 @@ export declare function seamCCompactionOptions(runner: RunnerDepsSeat, prepared:
  *  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">;
+export declare function compactionHookOptions(runner: RunnerDepsSeat, prepared: {
+    readonly modBus: LegModBus;
+    readonly hookIdentity: HookInvocationIdentity | undefined;
+    readonly sessionId: string;
+}, 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,14 +1,7 @@
 import { classicEventBase, dispatchClassic, observeClassic, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
 export function seamCCompactionOptions(runner, prepared) {
     return {
-        ...(runner.deps.summaryProvider
-            ? {
-                summaryProvider: runner.deps.summaryProvider,
-                onCompaction: runner.deps.onCompaction,
-                maxConsecutiveProviderReuse: runner.deps.maxConsecutiveProviderReuse,
-                consecutiveProviderReuse: prepared.compactionReuseRef.consecutive,
-            }
-            : {}),
+        ...summaryProviderOptions(runner, prepared.compactionReuseRef.consecutive),
         onCommitted: (effect) => {
             if (prepared.frameSettlement.wantsEffects?.() !== true)
                 return;
@@ -16,6 +9,16 @@ export function seamCCompactionOptions(runner, prepared) {
         },
     };
 }
+export function summaryProviderOptions(runner, consecutive) {
+    return runner.deps.summaryProvider
+        ? {
+            summaryProvider: runner.deps.summaryProvider,
+            onCompaction: runner.deps.onCompaction,
+            maxConsecutiveProviderReuse: runner.deps.maxConsecutiveProviderReuse,
+            consecutiveProviderReuse: consecutive,
+        }
+        : {};
+}
 export function compactionHookOptions(runner, prepared, trigger, signal) {
     const bus = prepared.modBus;
     const base = classicEventBase(prepared.hookIdentity);

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

@@ -3,6 +3,7 @@ import { checkedMediaByteCap } from "../media-byte-cap.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 { receiveHostFloor } from "../host-floor.js";
 import { holdOwnCredentialValues } from "../secret-env.js";
 export function retainRunnerDeps(deps) {
     const words = { subject: "RunnerDeps", unit: "seat", moment: "at new Runner" };
@@ -15,6 +16,8 @@ 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 });
     }
+    if (Object.hasOwn(retained, "hostFloor"))
+        Object.defineProperty(retained, "hostFloor", { value: receiveHostFloor(Reflect.get(retained, "hostFloor")), enumerable: true, writable: true, configurable: true });
     let consolidationKey;
     try {
         const chat = retained.memoryConsolidationDriver?.chat;