@sema-agent/core 7.18.0 → 7.19.0

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

@@ -1,6 +1,8 @@
 /**
- * The auto-mode classifier's CANDIDATE LADDER, as one module: which models a classification may be asked on,
- * its per-rung reasoning seat, and the once-per-run disclosure its first move mints.
+ * The auto-mode classifier's CANDIDATE LADDER, as one module: which models a classification may be asked on
+ * (and which model stands in when no `classifier` role names one), its per-rung reasoning seat and the
+ * per-attempt user-message tail, how a rung's reply is read for a re-ask or a failure, and the once-per-run
+ * disclosures its first move and its broken contract mint.
  *
  * Beside `derived-route-fallback.ts` and in the same family — both are seats the caps phase's classifier
  * arming reaches DOWN for, and both answer "this leg's model did not work out" one layer apart. Which is why
@@ -30,7 +32,7 @@
  * `modelRequested` reading above; the unification (the pre-flight as rung 0 under its own cause word, one
  * record face for both) changes the notice set and is a ticket, not a repair.
  */
-import type { Model } from "../../internal/llm.js";
+import type { AssistantMessage, Model } from "../../internal/llm.js";
 import { type AutoModeClassified } from "../auto-mode.js";
 import type { RunnerDeps } from "../types.js";
 /**
@@ -51,14 +53,69 @@ import type { RunnerDeps } from "../types.js";
  * loud refusal at the brain's request gate.
  */
 export declare function classifierLadderRungs(knob: unknown, classifier: Model, main: Model): readonly Model[];
+/**
+ * WHY the classifier seat is the model it is when no `classifier` role names one — the closed set behind the
+ * `classifier.role_defaulted` notice's `reason`. `tier_below_main` = the nearest directly-bound tier below the
+ * run's main model; `tier_table` = the static `flash` row (a main bound to no tier); `role_fallback` = the
+ * `summarize → default` chain (no tiers at all); `main_only` = the main model is the only model there is (a
+ * single-model catalog, or nothing bound below the main's tier); `role_unresolvable` = a `classifier` role
+ * NAMED a model the catalog cannot resolve (a stale or misspelled reference), so the main model stands in —
+ * the pre-#805 leg fell back the same way, silently.
+ */
+export declare const CLASSIFIER_ROLE_DEFAULT_REASONS: readonly ["tier_below_main", "tier_table", "role_fallback", "main_only", "role_unresolvable"];
+export type ClassifierRoleDefaultReason = (typeof CLASSIFIER_ROLE_DEFAULT_REASONS)[number];
+/** What {@link classifierSeatModel} returns: the model, and — when no role NAMED it — why it is that one. */
+export type ClassifierSeat = {
+    readonly model: Model;
+    readonly defaulted?: ClassifierRoleDefaultReason;
+};
+/**
+ * The model the classifier SEAT resolves to for this run — ONE resolver for "which model classifies":
+ *   · a `classifier` role that NAMES a model (`roleSpecNamesModel`: a string ref, a Model object, `{model}`,
+ *     `{select}`) ⇒ the role resolver's answer, exactly as before (a preset-only role — `{thinking}` alone —
+ *     does not name one and takes the default below);
+ *   · else, with tier bindings declared (`deps.tiers`) and a main model on a tier ⇒ the nearest tier strictly
+ *     BELOW the main's whose route differs from the main's — `tier_below_main`; the main's tier is the LOWEST
+ *     tier its route sits on (a route bound as both `max` and `flash` is a `flash` main: deterministic, and
+ *     the cheaper reading); nothing below ⇒ the main itself, `main_only`. Read off the expanded catalog's
+ *     tier keys, the Runner's own resolution of a tier word: a key synthesised for an unbound tier falls DOWN
+ *     to the next bound tier, which is the model this walk reaches anyway, and a catalog key spelled like a
+ *     tier shadows the binding here as it does everywhere. No thinking preference: whether a model's
+ *     thinking can be turned off is the SEAT's business ({@link classifierRungSeat}), not routing's;
+ *   · else the role resolver's own fallback (the static tier row `classifier → flash` when tiers are active,
+ *     `tier_table`; the `summarize → default` chain otherwise, `role_fallback`); a catalog with no roles at
+ *     all ⇒ the main model, `main_only`.
+ * The relative pick follows the run's MAIN model on purpose: a side channel that resolved without it is the
+ * misfit the ticket names (a `flash` classifier above a `lite` main; two tiers below a `max` main).
+ */
+export declare function classifierSeatModel(args: {
+    deps: Pick<RunnerDeps, "models" | "roles" | "tiers">;
+    main: Model;
+}): ClassifierSeat;
+/**
+ * The `classifier.role_defaulted` line — minted ONCE per run by the arming, AFTER the route pre-flight, so it
+ * names the seat actually asked (a pre-flight swap to the main model is its own line,
+ * `route.fallback_to_primary`, same run). Silent when a role named the model: nothing was defaulted.
+ */
+export declare function announceClassifierRoleDefaulted(args: {
+    onNotice: RunnerDeps["onNotice"];
+    seat: ClassifierSeat;
+    sessionId?: string;
+    runId?: string;
+}): void;
 /**
  * The classifier's REASONING SEAT, read off the model a classification is actually asked on — ONE predicate:
- * can the wire say off? Yes ⇒ `off` + the verdict-sized cap (the request pays for the answer alone); no ⇒
- * `low` + the verdict cap + the low-reasoning budget (a model that thinks regardless is told to think the
- * LEAST its wire can spell, in exactly the room that tier needs). PER RUNG, not once per arming: the second
- * rung is a different model with its own wire, and asking it under the first rung's seat is how a correct
- * fallback comes back with zero text. The `low` seat is also the re-ask seat: an unknown model that answers
- * NOTHING at the `off` cap has just told us it thinks anyway, and is re-asked as one that does.
+ * 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 — CC 2.1.259 `MU`: 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 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
+ * model that answered NOTHING at its cap has just told us it thinks past it, and is re-asked as one that does.
  */
 export declare const CLASSIFIER_OFF_SEAT: {
     reasoning: "off";
@@ -68,11 +125,92 @@ export declare const CLASSIFIER_LOW_SEAT: {
     reasoning: "low";
     maxTokens: number;
 };
+export declare const CLASSIFIER_THINK_SEAT: {
+    reasoning: "low";
+    maxTokens: number;
+};
+export type ClassifierSeatRequest = typeof CLASSIFIER_OFF_SEAT | typeof CLASSIFIER_LOW_SEAT | typeof CLASSIFIER_THINK_SEAT;
+/**
+ * The seat for one rung's FIRST attempt — see the seat table above.
+ *
+ * @contract classifier.budget_is_room — every classifier output cap is ROOM the request asks for, never a
+ * 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.
+ */
 export declare function classifierRungSeat(model: Model): typeof CLASSIFIER_OFF_SEAT | typeof CLASSIFIER_LOW_SEAT;
+/**
+ * The user-message TAIL of each attempt — CC 2.1.259's classifier suffixes, verbatim: the FIRST attempt
+ * carries the fast-mode suffix (`$ns`: the answer must begin with `<block>`, no preamble), the RE-ASK carries
+ * the thinking-stage suffix (`Uns`: think in `<thinking>` first, then answer). The base prompt (2.1.250 `KRg`)
+ * already says "no preamble" once; upstream repeats it at the END of the user message, and it is the repeat
+ * that lands — live 2026-09-15, a Qwen 3.8 with thinking off went from 70% tagged replies (1.2–3.9k chars of
+ * "Looking at this action…" prose) to 90% at 8 output tokens with the first suffix, and the re-ask suffix
+ * had it write its reasoning inside `<thinking>` (stripped by the reader) before the tag.
+ */
+export declare const CLASSIFIER_ATTEMPT_SUFFIX: {
+    readonly 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.";
+    readonly reask: "\nReview the classification process and follow it carefully, making sure you deny actions that should be blocked. As a reminder, explicit (not suggestive or implicit) user confirmation is required to override blocks. Use <thinking> before responding with <block>. Think longer on ambiguous or borderline actions; keep reasoning brief for clear-cut ones.";
+};
+/** The classifier reply's answer text — every text block joined; thinking blocks are not the verdict. */
+export declare function classifierReplyText(reply: AssistantMessage): string;
+/**
+ * CC 2.1.259 `$Tt`: an EMPTY reply that stopped at the output cap is "unparseable" — a reply to ask for again,
+ * not a refusal and not a verdict. The engine's brains report that cut two ways: `stopReason:"length"` (an
+ * engine-shrunk cap) or `stopReason:"error"` with `errorKind:"length_empty"` (a static cap — the classifier's
+ * own). An empty reply with any OTHER stop is CC's `policy_refusal` arm: not re-asked.
+ */
+export declare function classifierReplyEmptyAtCap(reply: AssistantMessage): boolean;
+/**
+ * A reply that may answer in the TAG form only: its text is not a complete answer of its own. Output cut by the cap
+ * (`stopReason: "length"`), a dropped connection or a stalled stream (`partialFinalized`, with a synthesised
+ * `stop`), and a reply that CALLED A TOOL (`stopReason: "toolUse"`, or a tool-call block in the content — the
+ * classifier is given no tools, and the openai brain reports a length cut with a surviving call as `toolUse`):
+ * whatever text arrived is a prefix or a fragment — a `No` on its way to `No, this must be blocked` — so it may
+ * carry a verdict only through a `<block>` tag, which reads a `<block>no` prefix as CC does; the bare-answer arm
+ * never sees it.
+ */
+export declare function classifierReplyTagOnly(reply: AssistantMessage): boolean;
+/**
+ * The text the DECIDER reads for its verdict: the reply's answer text, except that a tag-only reply
+ * ({@link classifierReplyTagOnly}) whose text carries NO tagged answer reads as EMPTY — a cut prefix must not
+ * reach the bare-answer arm as if it were the whole reply (adversarial passes 2–3: a connection cut after `No`,
+ * and a scratch `<block>` mention before a cut `No`, executed the gated tool). Judged by the reader itself with
+ * its bare arm closed, so "no tagged verdict" and "no verdict" cannot drift. Only the MISSING form is emptied:
+ * a tag-only reply that carries a CONFLICT keeps its text, so the decider records the conflict and the leg
+ * does not re-ask it (adversarial pass 4: emptying every parse failure had turned a cut conflict into a
+ * missing reply, and the re-ask into an allow). The decider then records `parse_error` / `missing` for the
+ * emptied text, the same word an empty reply gets.
+ */
+export declare function classifierReplyVerdictText(reply: AssistantMessage): string;
+/**
+ * Whether a first attempt is asked AGAIN on the THINK seat — ONE rule: the reply is MISSING a verdict, either
+ * empty at the cap ({@link classifierReplyEmptyAtCap}), cut or fragmentary without a tagged verdict
+ * ({@link classifierReplyTagOnly}), or text in which the reader finds no answer at all (`parse_error` of form
+ * `missing`: prose, a thinking-only reply). Not a CONFLICT (two `<block>` answers — it carries a `yes`, and a second attempt that answered `no`
+ * would erase it: the fail-closed `parse_error` it is stands) and not an empty reply with a non-cap stop
+ * (CC's refusal arm). CC 2.1.259 `Vrr` re-asks an unparseable reply up to `maxRetries` times; sema re-asks
+ * ONCE, on the stage-2 room, so a rung costs at most two calls. A failed reply ({@link classifierReplyFailure})
+ * is judged before this and never reaches it.
+ */
+export declare function classifierReplyAsksAgain(reply: AssistantMessage): boolean;
+/**
+ * A reply that is a LEG FAILURE rather than an answer — the brains RETURN a provider error as a message
+ * (`stopReason: "error"` with the provider's text on `errorMessage`: an HTTP 4xx/5xx, a quota refusal, an
+ * overloaded gateway) and a cancelled request as `"aborted"`; neither is a reply the reader may judge. Read as
+ * text they were `parse_error` — a card saying "the classifier's reply carried no verdict" about a model that
+ * never answered, a ladder record blaming `parse_error` instead of `error`. The leg THROWS what this returns
+ * and the decider maps the throw to `unavailable` (`error`), as it maps every leg failure; the sibling
+ * side-channel legs (compaction, consolidation) already read an error stop this way. The cap-cut form
+ * (`errorKind: "length_empty"`) is not a failure: it is the empty-at-cap reply the re-ask owns.
+ */
+export declare function classifierReplyFailure(reply: AssistantMessage): Error | undefined;
 /**
  * The per-decision READ of a classification, as one seat: the `auto_mode.classified` trace frame (wall time,
- * verdict, cause) and the ladder's throttled `classifier.fallback` disclosure. Both are observers — a
- * throwing sink never reaches the gate (the decider swallows it), and neither changes a verdict.
+ * verdict, cause), the ladder's throttled `classifier.fallback` disclosure and the per-model
+ * `classifier.contract_broken` streak. All are observers — a throwing sink never reaches the gate (the decider
+ * swallows it), and none changes a verdict.
  *
  * The frame's `model` is the model the classification RAN ON, which is what the field has always meant (its
  * declaration reads "the resolved classifier role, or the main model it fell back to"): the route

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

@@ -1,20 +1,87 @@
 import { sameRouteIdentity } from "../../brain/route-adjudicator.js";
-import { thinkingOffExpressible } from "../../brain/reasoning.js";
-import { AUTO_MODE_CLASSIFIER_LOW_REASONING_BUDGET_TOKENS, AUTO_MODE_CLASSIFIER_MAX_TOKENS } from "../auto-mode-defaults.js";
-import { autoModeClassifierFallbackOf } from "../auto-mode.js";
+import { thinkingOffSpelled } from "../../brain/reasoning.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 { DEFAULT_TIER_ORDER, resolveTaskModel, roleSpecNamesModel } from "../roles.js";
 import { emitTrace } from "../trace.js";
 import { deliverEngineNotice } from "../types.js";
 export function classifierLadderRungs(knob, classifier, main) {
     if (autoModeClassifierFallbackOf(knob) === "none")
         return [classifier];
-    let sameRoute;
+    return sameRouteQuietly(classifier, main) ? [classifier] : [classifier, main];
+}
+function sameRouteQuietly(a, b) {
     try {
-        sameRoute = sameRouteIdentity(classifier, main);
+        return sameRouteIdentity(a, b);
     }
     catch {
-        sameRoute = false;
+        return false;
     }
-    return sameRoute ? [classifier] : [classifier, main];
+}
+export const CLASSIFIER_ROLE_DEFAULT_REASONS = ["tier_below_main", "tier_table", "role_fallback", "main_only", "role_unresolvable"];
+export function classifierSeatModel(args) {
+    const { deps, main } = args;
+    if (roleSpecNamesModel(deps.roles?.classifier)) {
+        try {
+            return { model: resolveTaskModel({ modelRole: "classifier" }, deps).model };
+        }
+        catch {
+            return { model: main, defaulted: "role_unresolvable" };
+        }
+    }
+    const below = tierBelowMain(deps, main);
+    if (below !== undefined)
+        return below;
+    try {
+        const model = resolveTaskModel({ modelRole: "classifier" }, deps).model;
+        if (sameRouteQuietly(model, main))
+            return { model, defaulted: "main_only" };
+        return { model, defaulted: deps.tiers !== undefined && Object.keys(deps.tiers).length > 0 ? "tier_table" : "role_fallback" };
+    }
+    catch {
+        return { model: main, defaulted: "main_only" };
+    }
+}
+function tierBelowMain(deps, main) {
+    if (deps.tiers === undefined || Object.keys(deps.tiers).length === 0 || deps.models === undefined)
+        return undefined;
+    const bound = DEFAULT_TIER_ORDER.map((tier) => deps.models?.[tier]);
+    let mainTier = -1;
+    for (let i = bound.length - 1; i >= 0; i--) {
+        const m = bound[i];
+        if (m !== undefined && sameRouteQuietly(m, main)) {
+            mainTier = i;
+            break;
+        }
+    }
+    if (mainTier < 0)
+        return undefined;
+    for (let i = mainTier + 1; i < bound.length; i++) {
+        const m = bound[i];
+        if (m !== undefined && !sameRouteQuietly(m, main))
+            return { model: m, defaulted: "tier_below_main" };
+    }
+    return { model: main, defaulted: "main_only" };
+}
+export function announceClassifierRoleDefaulted(args) {
+    const { seat } = args;
+    if (seat.defaulted === undefined)
+        return;
+    const spelled = thinkingOffSpelled(seat.model);
+    deliverEngineNotice(args.onNotice, {
+        code: "classifier.role_defaulted",
+        message: `no classifier role names a model — "${seat.model.id}" classifies this run (${seat.defaulted}); ` +
+            (spelled ? "its wire can turn thinking off for the verdict. " : "its wire cannot turn thinking off, so each classification carries a thinking allowance. ") +
+            "Name a `classifier` role, or declare the model's thinking format (`compat.thinkingFormat`) so the seat can spell off.",
+        detail: {
+            model: seat.model.id,
+            reason: seat.defaulted,
+            thinkingOffSpelled: spelled,
+            ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
+            ...(args.runId !== undefined ? { runId: args.runId } : {}),
+        },
+        ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
+    });
 }
 function classifierFallbackAnnouncer(args) {
     const announced = new Set();
@@ -41,13 +108,94 @@ function classifierFallbackAnnouncer(args) {
         });
     };
 }
+function classifierContractAnnouncer(args) {
+    const streak = new Map();
+    const announced = new Set();
+    const noVerdict = (rung, model) => {
+        const key = `${rung}:${model}`;
+        const n = (streak.get(key) ?? 0) + 1;
+        streak.set(key, n);
+        if (n < AUTO_MODE_CLASSIFIER_CONTRACT_BROKEN_AFTER || announced.has(key))
+            return;
+        announced.add(key);
+        deliverEngineNotice(args.onNotice, {
+            code: "classifier.contract_broken",
+            message: `the auto-mode classifier model "${model}" has answered ${n} consecutive classifications without a verdict (each asked twice) — ` +
+                "every gated call it judges is denied. Declare the model's thinking format (`compat.thinkingFormat`) so the seat can turn thinking off, " +
+                "or name a `classifier` role whose model follows the <block> contract.",
+            detail: {
+                model,
+                rung,
+                consecutive: n,
+                ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
+                ...(args.runId !== undefined ? { runId: args.runId } : {}),
+            },
+            ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}),
+        });
+    };
+    return (info) => {
+        const record = info.classifier;
+        if (record === undefined)
+            return;
+        if (record.fallback?.cause === "parse_error")
+            noVerdict(0, record.fallback.from);
+        const landed = record.fallback !== undefined ? 1 : 0;
+        if (info.verdict === "parse_error")
+            noVerdict(landed, record.modelUsed);
+        else if (info.verdict === "allow" || info.verdict === "block")
+            streak.delete(`${landed}:${record.modelUsed}`);
+    };
+}
 export const CLASSIFIER_OFF_SEAT = { reasoning: "off", maxTokens: AUTO_MODE_CLASSIFIER_MAX_TOKENS };
 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 thinkingOffExpressible(model) ? CLASSIFIER_OFF_SEAT : CLASSIFIER_LOW_SEAT;
+    return thinkingOffSpelled(model) ? 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.',
+    reask: "\nReview the classification process and follow it carefully, making sure you deny actions that should be blocked. As a reminder, explicit (not suggestive or implicit) user confirmation is required to override blocks. Use <thinking> before responding with <block>. Think longer on ambiguous or borderline actions; keep reasoning brief for clear-cut ones.",
+};
+export function classifierReplyText(reply) {
+    return reply.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("");
+}
+export function classifierReplyEmptyAtCap(reply) {
+    if (classifierReplyText(reply) !== "")
+        return false;
+    return reply.stopReason === "length" || (reply.stopReason === "error" && reply.errorKind === "length_empty");
+}
+export function classifierReplyTagOnly(reply) {
+    return reply.stopReason === "length" || reply.stopReason === "toolUse" || reply.partialFinalized === true || reply.content.some((c) => c.type === "toolCall");
+}
+export function classifierReplyVerdictText(reply) {
+    const text = classifierReplyText(reply);
+    if (!classifierReplyTagOnly(reply))
+        return text;
+    const tagged = parseAutoModeResponse(text, { bareAnswer: false });
+    return tagged.kind === "parse_error" && tagged.form === "missing" ? "" : text;
+}
+export function classifierReplyAsksAgain(reply) {
+    if (classifierReplyEmptyAtCap(reply))
+        return true;
+    const text = classifierReplyVerdictText(reply);
+    if (text === "")
+        return classifierReplyTagOnly(reply) && classifierReplyText(reply) !== "";
+    const verdict = parseAutoModeResponse(text);
+    return verdict.kind === "parse_error" && verdict.form === "missing";
+}
+export function classifierReplyFailure(reply) {
+    if (reply.stopReason === "aborted")
+        return new Error("the auto-mode classifier request was aborted");
+    if (reply.stopReason !== "error" || reply.errorKind === "length_empty")
+        return undefined;
+    return new Error(`the auto-mode classifier request failed: ${reply.errorMessage ?? "the model leg reported an error with no message"}`);
 }
 export function classifierRoundObserver(args) {
-    const announce = classifierFallbackAnnouncer(args);
+    const announceFallback = classifierFallbackAnnouncer(args);
+    const countContract = classifierContractAnnouncer(args);
     return (info) => {
         emitTrace(args.tracer, () => ({
             kind: "auto_mode.classified",
@@ -60,6 +208,7 @@ export function classifierRoundObserver(args) {
             ...(info.cause !== undefined ? { cause: info.cause } : {}),
             ts: Date.now(),
         }));
-        announce(info.classifier);
+        announceFallback(info.classifier);
+        countContract(info);
     };
 }

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

@@ -32,6 +32,7 @@ import type { ClearedProjectionLedger, MicroCompactMachine, OccurrenceIndex } fr
 import type { HookInvocationIdentity, Hooks, OrgGateVerdict, PermissionDeniedPayload, PostToolBatchCall, PostToolBatchResult, ToolGateInput } from "../hooks.js";
 import type { MaterializedMcp } from "../mcp.js";
 import type { MemoryEngine } from "../memory-engine/engine.js";
+import type { ResolvedSkillListingBudget } from "../skill-listing-budget.js";
 import type { HarvestReport, MemorySessionHandle } from "../memory-engine/types.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";
 import type { RecoveredOrphan } from "../session-reconcile.js";
@@ -1024,6 +1025,7 @@ export interface Prepared {
     skillsListing?: {
         entries: ReadonlyArray<SkillListingEntry>;
         seedAnnounced: boolean;
+        budget: ResolvedSkillListingBudget;
     };
     /** [c209-C] Q5 — the run loop's live mirror of the listing frames' announced NAME-SETS (updated at
      *  every commit point: first-frame delivery, intact boundary survival, resume seed). Read by the

package/dist/core/runner/denial-limit-arms.js

@@ -1,4 +1,4 @@
-import { CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE, classifierUnavailableDenyMessage, createAutoModeDenialTracker, denialLimitFallbackMessage, denialLimitSentence, unarmedWindow } from "../auto-mode.js";
+import { classifierParseFailureDenyMessage, classifierUnavailableDenyMessage, createAutoModeDenialTracker, denialLimitFallbackMessage, denialLimitSentence, unarmedWindow } from "../auto-mode.js";
 import { sanitizeAutoModeArmingRecipe, tightenDenialLimit } from "../auto-mode-arming.js";
 import { attestClassifierDenyCause } from "../tool-policy.js";
 import { deliverEngineNotice } from "../types.js";
@@ -92,7 +92,7 @@ export async function judgeInheritedClassifier(opts) {
             result: attestClassifierDenyCause({ action: "deny", message: classifierUnavailableDenyMessage(req.toolName, verdict.cause), decisionReason: "classifier" }, "unavailable", req),
         };
     }
-    const reason = verdict.kind === "block" ? (verdict.reason ? inlineUntrusted(verdict.reason) : "") : CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE;
+    const reason = verdict.kind === "block" ? (verdict.reason ? inlineUntrusted(verdict.reason) : "") : classifierParseFailureDenyMessage(verdict.classifier);
     const category = verdict.kind === "block" && verdict.category ? inlineUntrusted(verdict.category) : "";
     const tracked = autoMode.denialTracking?.recordBlock();
     if (tracked?.limitReached !== true) {

package/dist/core/runner/prepare-ask-lane.js

@@ -102,6 +102,7 @@ export function prepareAskLane(input) {
             ...(decision.action === "ask" ? gateAskCarry(decision, isLiveApproverSeat(onAsk), autoModeDenialTracking) : {}),
             ...(decision.action === "ask" && decision.probeReason !== undefined ? { probeReason: decision.probeReason } : {}),
             ...(decision.action === "ask" && decision.probeCause !== undefined ? { probeCause: decision.probeCause } : {}),
+            ...(decision.action === "ask" && decision.probeReadRootCandidate !== undefined ? { readRootCandidate: decision.probeReadRootCandidate } : {}),
             ...(decision.action === "ask" && decision.ruleEvidence !== undefined ? { ruleEvidence: decision.ruleEvidence } : {}),
         }, onAsk, composedCallSignal(callSignal), lateAskSettlementObserver({ toolName: req.toolName, toolCallId: req.toolCallId, sessionId, runId, ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), onNotice: deps.onNotice, onError: deps.onError }));
         const waitMs = Math.max(0, now() - t0);

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -11,26 +11,14 @@ import { autoModeClassifierFallbackOf, autoModeRoundNotAsked, createAutoModeDeci
 import { checkpointStoreOfSeat } from "../checkpoint-seat.js";
 import { COMPLIANCE_CAPABILITIES, WEB_FETCH_TOOL_NAME, resolveComplianceDenies } from "../compliance.js";
 import { createPresentPlanTool, createEnterPlanModeTool } from "../present-plan-tool.js";
-import { resolveTaskModel } from "../roles.js";
 import { brainToRuntime } from "../runtime.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { defineTool, isDefineToolProduct, rebindDefineToolCtx } from "../tools.js";
 const MOUNT_REMEDY = "author it as a plain-object ToolSpec (own `name` and `execute`), hand the defineTool product itself, or wrap a product through the supported wrapper form (a fresh object re-stamped with `stampDefineToolBrand` whose rebind re-wraps the rebound product)";
 import { AUTO_MODE_DENY_SOURCES, isAutoModeDenySource } from "../runtime-caps.js";
 import { derivedRouteFallsBack } from "./derived-route-fallback.js";
-import { CLASSIFIER_LOW_SEAT, CLASSIFIER_OFF_SEAT, classifierLadderRungs, classifierRoundObserver, classifierRungSeat } from "./classifier-ladder.js";
+import { CLASSIFIER_ATTEMPT_SUFFIX, CLASSIFIER_THINK_SEAT, announceClassifierRoleDefaulted, classifierLadderRungs, classifierReplyAsksAgain, classifierReplyFailure, classifierReplyVerdictText, classifierRoundObserver, classifierRungSeat, classifierSeatModel } from "./classifier-ladder.js";
 import { REPORT_FINDINGS_TOOL_NAME, createReportBlockedTool, createReportFindingsTool } from "./synthetic-tools.js";
-function classifierReplyText(reply) {
-    return reply.content
-        .filter((c) => c.type === "text")
-        .map((c) => c.text)
-        .join("");
-}
-function classifierReplyEmptyAtCap(reply) {
-    if (classifierReplyText(reply) !== "")
-        return false;
-    return reply.stopReason === "length" || (reply.stopReason === "error" && reply.errorKind === "length_empty");
-}
 import { RosterBuilder, callerMountSource } from "../tool-roster.js";
 function assembleParentCaptureState(o, i, ctl, ancestors) {
     const build = (optedOut, indeterminate) => ({
@@ -209,16 +197,12 @@ export async function prepareCapsAndWorkflow(input) {
     const autoModeArmReason = autoModeArmReasonOf(autoModeIntent, deps.autoMode !== undefined, runtimeCaps, runtimeCapsFaulted);
     if (autoModeIntent && deps.autoMode !== undefined && runtimeCaps?.autoMode !== false) {
         const am = deps.autoMode;
-        let classifierModel;
-        try {
-            classifierModel = resolveTaskModel({ modelRole: "classifier" }, deps).model;
-        }
-        catch {
-            classifierModel = model;
-        }
+        const classifierSeat = classifierSeatModel({ deps, main: model });
+        let classifierModel = classifierSeat.model;
         if (await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId, onBrokenPairing: autoModeClassifierFallbackOf(am.classifierFallback) === "none" ? "refuse" : "fall_back" })) {
             classifierModel = model;
         }
+        announceClassifierRoleDefaulted({ onNotice: deps.onNotice, seat: { ...classifierSeat, model: classifierModel }, ...(sessionId !== undefined ? { sessionId } : {}), ...(runId !== undefined ? { runId } : {}) });
         const classifierLaneRule = peerLaneActive && peerSendMessageBuiltIn;
         const classifierSystemPrompt = buildAutoModePrompt(classifierLaneRule ? { ...am, crossSessionMessagesRule: CROSS_SESSION_CLASSIFIER_RULE } : am);
         const classifierRuntime = brainToRuntime(deps.brain);
@@ -245,17 +229,22 @@ export async function prepareCapsAndWorkflow(input) {
                 }
                 const userPrompt = await build.catch((e) => { throw autoModeRoundNotAsked(e); });
                 const classifierAuth = await spec.getApiKeyAndHeaders?.(rungModel);
-                const request = (seat) => classifierRuntime.completeSimple(rungModel, { systemPrompt: classifierSystemPrompt, messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }] }, {
-                    signal,
-                    ...seat,
-                    ...(classifierAuth?.apiKey !== undefined ? { apiKey: classifierAuth.apiKey } : {}),
-                    ...(classifierAuth?.headers !== undefined ? { headers: classifierAuth.headers } : {}),
-                });
-                const rungSeat = classifierRungSeat(rungModel);
-                let response = await request(rungSeat);
-                if (rungSeat === CLASSIFIER_OFF_SEAT && classifierReplyEmptyAtCap(response))
-                    response = await request(CLASSIFIER_LOW_SEAT);
-                return classifierReplyText(response);
+                const request = async (seat, suffix) => {
+                    const response = await classifierRuntime.completeSimple(rungModel, { systemPrompt: classifierSystemPrompt, messages: [{ role: "user", content: userPrompt + suffix, timestamp: Date.now() }] }, {
+                        signal,
+                        ...seat,
+                        ...(classifierAuth?.apiKey !== undefined ? { apiKey: classifierAuth.apiKey } : {}),
+                        ...(classifierAuth?.headers !== undefined ? { headers: classifierAuth.headers } : {}),
+                    });
+                    const failure = classifierReplyFailure(response);
+                    if (failure !== undefined)
+                        throw failure;
+                    return response;
+                };
+                let response = await request(classifierRungSeat(rungModel), CLASSIFIER_ATTEMPT_SUFFIX.first);
+                if (classifierReplyAsksAgain(response) && signal?.aborted !== true)
+                    response = await request(CLASSIFIER_THINK_SEAT, CLASSIFIER_ATTEMPT_SUFFIX.reask);
+                return classifierReplyVerdictText(response);
             },
         });
         if (am.persistArming === true)

package/dist/core/runner/prepare-config-doors.d.ts

@@ -25,6 +25,7 @@ import type { ThinkingLevel } from "../../internal/harness.js";
 import { type MicroCompactMachine } from "../context-edit.js";
 import { type LockedPreflight } from "../locked-config.js";
 import { type ResolvedRole } from "../roles.js";
+import { type ResolvedSkillListingBudget } from "../skill-listing-budget.js";
 import type { SessionStore } from "../session.js";
 import type { RunnerDeps, TaskLimits, TaskSpec } from "../types.js";
 import { type UsageWindow } from "../usage-window-store.js";
@@ -184,6 +185,11 @@ export interface PrepareConfigDoorsResult {
      *  mutated (or getter-backed) after the door must not present an unscreened value to the mark
      *  branch (the read-once posture). */
     memoryDelegationEvidence: "static-face" | "attested-only";
+    /** owned — the lowered skills-listing budget seats (`TaskSpec.skillListingBudgetFraction` /
+     *  `skillListingMaxDescChars`): the renderer's two numbers, resolved once against the resolved main
+     *  model's window. Read at the door so a bad value refuses BEFORE session acquisition, and carried so
+     *  the listing phase and the boundary renderer measure against the same resolution. */
+    skillListingBudget: ResolvedSkillListingBudget;
     /** owned — the NORMALIZED memory-provenance mode: the deps seat read ONCE in
    *  the synchronous pre-await stretch, screened, absent folded to the `"carry"` default.
      *  The memory phase constructs every engine with THIS value — never a live deps re-read. */

package/dist/core/runner/prepare-config-doors.js

@@ -7,6 +7,8 @@ import { isModelPriced, malformedPricingField, modelCostToPricing } from "../pri
 import { preflightLockedConfig } from "../locked-config.js";
 import { assertRetentionCapability } from "../retention.js";
 import { resolveModel, resolveTaskModel, roleModelIfSet } from "../roles.js";
+import { resolveSkillListingBudget } from "../skill-listing-budget.js";
+import { describeRejectedValue } from "../tool-search-setting.js";
 import { applyToolModelGate, assertRestoreGatedToolsValue, modelIdTail } from "../tool-model-gate.js";
 import { resolveUsageWindows } from "../usage-window-store.js";
 import { deriveAskEffective, resolveAskSeamForm, resolveQuestionSeam } from "../wiring-manifest.js";
@@ -35,16 +37,6 @@ export function limitConfigError(code, message) {
     e.code = code;
     return e;
 }
-function describeRejectedValue(value) {
-    try {
-        const quoted = JSON.stringify(value);
-        if (quoted !== undefined)
-            return quoted;
-    }
-    catch {
-    }
-    return `a ${typeof value} value`;
-}
 export function resolveTaskLimits(limits) {
     if (limits === undefined)
         return undefined;
@@ -416,6 +408,11 @@ export function prepareConfigDoors(input) {
     if (gateDecision.survivors !== undefined) {
         spec = { ...spec, tools: gateDecision.survivors };
     }
+    const skillListingBudget = resolveSkillListingBudget({
+        fraction: spec.skillListingBudgetFraction,
+        maxDescChars: spec.skillListingMaxDescChars,
+        model,
+    });
     const modelGate = Object.freeze({
         removedByClass: gateDecision.removedByClass,
         unknownClasses: gateDecision.unknownClasses,
@@ -439,6 +436,7 @@ export function prepareConfigDoors(input) {
         fableMitigations,
         modelGate,
         memoryDelegationEvidence,
+        skillListingBudget,
         memoryProvenance,
         memoryCapturePolicy,
         usageWindows,

package/dist/core/runner/prepare-project-context.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedSkillListingBudget } from "../skill-listing-budget.js";
 import { type StoredSession } from "../session.js";
 import type { RunnerDeps, TaskSpec, ToolSpec } from "../types.js";
 import type { ActiveSkillScope } from "./active-skill-scope.js";
@@ -8,7 +9,7 @@ export interface PrepareProjectContextInput {
     /** borrowed-readonly — the deployment seams this phase reads: `loadProjectMemory` (the snapshot),
      *  `onError` (the operator lane for a throwing seam / seeding / oversize skill), `sharedMemoryStores`
      *  (the shared-memory pair's switch: wired ⇒ mount). Receiver preserved (`deps.onError?.(…)`). */
-    deps: Pick<RunnerDeps, "loadProjectMemory" | "onError" | "sharedMemoryStores">;
+    deps: Pick<RunnerDeps, "loadProjectMemory" | "onError" | "sharedMemoryStores" | "onNotice">;
     /** borrowed-readonly — the REBOUND spec (`spec′`). Read: `sessionId` (phase derivation + the
      *  continuation projections), `skills` (the roster), `principal` (the shared-memory tools' trusted
      *  identity). Never mutated. */
@@ -69,6 +70,9 @@ export interface PrepareProjectContextInput {
     /** borrowed-readonly — the durable-resume carrier; read for `!== undefined` (seedAnnounced) and
      *  `seed.announcedListings.skills` (the removal-to-zero projection's gate). */
     resume: Pick<PrepareResume, "seed"> | undefined;
+    /** borrowed-readonly — the lowered listing-budget seats from the config door. The listing projection
+     *  carries it to the boundary renderer, and the over-budget disclosure below is priced against it. */
+    skillListingBudget: ResolvedSkillListingBudget;
 }
 export interface PrepareProjectContextResult {
     /** owned — the memory block with the project layer appended at the tail (unchanged when the seam is

package/dist/core/runner/prepare-project-context.js

@@ -9,7 +9,7 @@ import { SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, createSkillTool, normalizeSki
 import { substitutedSkillLength } from "./skill-base-dir.js";
 import { RosterBuilder } from "../tool-roster.js";
 export async function prepareProjectContext(input) {
-    const { deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume } = input;
+    const { deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume, skillListingBudget } = input;
     const tools = roster.tools;
     let memoryBlock = memoryBlockFromEngine;
     let instructionSources;
@@ -142,11 +142,12 @@ export async function prepareProjectContext(input) {
                 ...(declaredSkillRank.get(s.name) !== undefined ? { declaredRank: declaredSkillRank.get(s.name) } : {}),
             })),
             seedAnnounced: resume !== undefined || spec.sessionId !== undefined,
+            budget: skillListingBudget,
         }
         :
             (resume?.seed.announcedListings?.skills?.length ?? 0) > 0 || spec.sessionId !== undefined
                 ?
-                    { entries: [], seedAnnounced: true }
+                    { entries: [], seedAnnounced: true, budget: skillListingBudget }
                 : undefined;
     return { memoryBlock, instructionSources, projectInstructionContent, skillSpecs, hasSkillManifest, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted };
 }