@sema-agent/core 7.54.1 → 7.55.0

package/dist/core/runner/advisor-tool.js

@@ -0,0 +1,112 @@
+import { Type } from "typebox";
+import { stripErrorCodePrefix, thrownBrainFailure } from "../../brain/errors.js";
+import { ADVISOR_TOOL_NAME, advisorFailureHolds, advisorHoldOf } from "../advisor-verdict.js";
+import { runSideQuery } from "../side-query.js";
+import { thrownText } from "../thrown-value.js";
+import { defineTool } from "../tools.js";
+import { mountRuleFace, toolFace } from "../tool-catalog-entries.js";
+import { egressText } from "../untrusted-egress.js";
+const ADVISOR_MESSAGE_MAX_CHARS = 2_000;
+export const ADVISOR_SYSTEM_PROMPT = `You are the advisor: a stronger reviewer model consulted by an agent in the middle of its task. Above is the agent's conversation as it stood in the agent's last request — its task, every tool call it made and every result it saw — ending at the point where it asked for advice.
+
+Reply in plain text only. Do not call tools: any tool call you make is discarded and counts as no answer. Be concrete and short: name the decision the agent is facing, say what you would do and why, point at the specific evidence in the conversation that supports it, and flag anything the agent has assumed without checking. If the agent asked before declaring the task done, review the deliverable against the task as stated and list what is missing or wrong. If something you need is not in the conversation, say what is missing and what the agent should check first — that is still guidance.`;
+export const ADVISOR_HANDOFF = "You are the advisor now. Review everything above and reply with your guidance.";
+const AGENT_INSTRUCTIONS_HEADER = "# The agent's instructions (context for you; they bind the agent, not you)";
+const HOLD_SENTENCE = "The advisor is off for this conversation until it is compacted; do not call it again before then.";
+function unavailable(model, failure, message, hold, extra = {}) {
+    const cause = failure.errorKind ?? failure.code ?? failure.stopReason;
+    const bounded = message !== undefined && message.trim() !== "" ? egressText("same-principal", message).slice(0, ADVISOR_MESSAGE_MAX_CHARS) : undefined;
+    const text = [`Advisor unavailable${cause !== undefined ? ` (${cause})` : ""}.`, ...(bounded !== undefined ? [bounded] : []), ...(hold ? [HOLD_SENTENCE] : [])].join(" ");
+    const card = {
+        type: "advisor",
+        outcome: "unavailable",
+        model: model.id,
+        ...extra,
+        ...(failure.stopReason !== undefined ? { stopReason: failure.stopReason } : {}),
+        ...(failure.code !== undefined ? { code: failure.code } : {}),
+        ...(failure.errorKind !== undefined ? { errorKind: failure.errorKind } : {}),
+        ...(hold ? { hold: true } : {}),
+    };
+    return { text, card };
+}
+function askingTurn(branch, toolCallId) {
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const e = branch[i];
+        if (e.type !== "message" || e.message.role !== "assistant")
+            continue;
+        const m = e.message;
+        if (!m.content.some((c) => c.type === "toolCall" && c.id === toolCallId))
+            continue;
+        return { ...m, content: m.content.filter((c) => c.type !== "toolCall" || c.id === toolCallId) };
+    }
+    return undefined;
+}
+function projection(sent, turn, toolCallId) {
+    const close = { role: "toolResult", toolCallId, toolName: ADVISOR_TOOL_NAME, content: [{ type: "text", text: ADVISOR_HANDOFF }], isError: false };
+    return [...sent.messages, turn, close];
+}
+function systemPromptOf(sent) {
+    const sentSystemText = sent.systemPrompt ?? sent.systemBlocks?.map((b) => b.text).join("") ?? "";
+    return sentSystemText === "" ? ADVISOR_SYSTEM_PROMPT : `${ADVISOR_SYSTEM_PROMPT}\n\n${AGENT_INSTRUCTIONS_HEADER}\n${sentSystemText}`;
+}
+function outcomeOf(model, r) {
+    const served = r.servedModel !== model.id ? { servedModel: r.servedModel } : {};
+    const base = { type: "advisor", model: model.id, ...served, stopReason: r.stopReason, usage: r.usage };
+    if ((r.stopReason === "stop" || r.stopReason === "length") && r.text.trim() !== "")
+        return { text: r.text, card: { ...base, outcome: "reviewed" } };
+    if (r.stopReason === "error" && r.errorCode === "refusal") {
+        const reason = r.errorMessage !== undefined ? stripErrorCodePrefix(r.errorMessage).trim() : "";
+        const bounded = reason !== "" ? egressText("same-principal", reason).slice(0, ADVISOR_MESSAGE_MAX_CHARS) : "";
+        return { text: `Advisor declined to advise on this request.${bounded !== "" ? ` Reason: ${bounded}` : ""}`, card: { ...base, outcome: "declined" } };
+    }
+    const failure = { ...(r.errorCode !== undefined ? { code: r.errorCode } : {}), ...(r.errorKind !== undefined ? { errorKind: r.errorKind } : {}), ...(r.inputTooLongRuledOut === true ? { inputTooLongRuledOut: true } : {}) };
+    const message = r.stopReason === "toolUse" ? "the advisor model answered with a tool call instead of guidance" : r.stopReason === "error" || r.stopReason === "aborted" ? (r.errorMessage !== undefined ? stripErrorCodePrefix(r.errorMessage) : undefined) : "the advisor model returned no guidance";
+    return unavailable(model, { ...failure, stopReason: r.stopReason }, message, advisorFailureHolds(failure), { ...served, usage: r.usage });
+}
+async function consult(seat, toolCallId, signal) {
+    const model = seat.model;
+    let branch;
+    try {
+        branch = await seat.readBranch();
+    }
+    catch {
+        return unavailable(model, {}, "the advisor's availability for this conversation could not be read; try again later", false);
+    }
+    const held = advisorHoldOf(branch);
+    if (held !== undefined)
+        return unavailable(model, held, undefined, true);
+    const sent = seat.lastSentRequest();
+    if (sent === undefined)
+        return unavailable(model, {}, "no request has been sent to the model on this resumed run yet; call advisor again", false);
+    const turn = askingTurn(branch, toolCallId) ?? { role: "assistant", content: [{ type: "toolCall", id: toolCallId, name: ADVISOR_TOOL_NAME, arguments: {} }] };
+    try {
+        const r = await runSideQuery({
+            model,
+            systemPrompt: systemPromptOf(sent),
+            messages: projection(sent, turn, toolCallId),
+            ...(sent.tools !== undefined && sent.tools.length > 0 ? { tools: sent.tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })) } : {}),
+            ...(signal !== undefined ? { signal } : {}),
+            ...(seat.getApiKeyAndHeaders !== undefined ? { getApiKeyAndHeaders: seat.getApiKeyAndHeaders } : {}),
+        }, { brain: seat.brain });
+        return outcomeOf(model, r);
+    }
+    catch (e) {
+        seat.markUsageUnknown();
+        const failure = thrownBrainFailure(e);
+        return unavailable(model, { ...failure, stopReason: "error" }, stripErrorCodePrefix(thrownText(e)), advisorFailureHolds(failure));
+    }
+}
+export function createAdvisorTool(seat) {
+    return defineTool({
+        name: ADVISOR_TOOL_NAME,
+        ...toolFace("advisor"),
+        ruleFace: mountRuleFace("advisor"),
+        label: seat.model.id,
+        description: "Consult the advisor: a stronger reviewer model reads this conversation and returns guidance. Takes no parameters.",
+        parameters: Type.Object({}),
+        execute: async (_args, ctx) => {
+            const { text, card } = await consult(seat, ctx.toolCallId, ctx.signal);
+            return { content: text, details: card, isError: card.outcome === "unavailable" };
+        },
+    });
+}

package/dist/core/runner/announce-once-ledger.d.ts

@@ -1,6 +1,5 @@
 import type { AnnouncedListingSnapshot, AnnouncedListingSnapshotInput, AnnouncedMcpFailure } from "../../internal/harness.js";
-import type { SessionTreeEntry } from "../../internal/harness-types.js";
-import type { AnnounceOnceSink, DateAnchorRead } from "./contracts.js";
+import type { AnnounceOnceSink } from "./contracts.js";
 import type { McpDroppedTool, McpServerStatus } from "../mcp.js";
 import type { RunnerDeps } from "../types.js";
 /** Upper bound on the advisory-digest arm kept in the record (oldest dropped past it). A digest is
@@ -85,6 +84,9 @@ export interface AnnounceOnceLedger {
      *  the record is dropped; a new one is forwarded to `deps.onError` and recorded. With no sink wired
      *  nothing is recorded either — "announced" means delivered. Same signature as `RunnerDeps.onError`. */
     onError: NonNullable<RunnerDeps["onError"]>;
+    /** The record's one dedupe verb, for any announcement of a session fact: `deliver` runs unless `digest` is already in the
+     *  record, and the digest is recorded once it ran ({@link onError} is this verb over the operator sink). */
+    oncePerSession(digest: string, deliver: () => void): void;
     /** The operator-lane sink for a DEPLOYMENT fact (see {@link AnnounceOnceSink.onErrorOncePerRunner}): the same
      *  `(code, message)` digest, judged against what THIS RUNNER's sink has already been told rather than against
      *  the session's record. Writes no digest into the record and owes the transcript nothing. */
@@ -127,28 +129,4 @@ export declare function loadAnnounceOnceLedger(session: AnnounceOnceSession, che
  *  present-only arms, copied; `undefined` when nothing was announced on any face (the resume seed
  *  then falls to the lower rungs — unchanged contract). */
 export declare function serializeAnnouncedListings(ref: AnnouncedListingSnapshotInput): AnnouncedListingSnapshot | undefined;
-/** The custom-entry kind that carries the session's date anchor (engine-owned; never model-visible). */
-export declare const DATE_ANCHOR_CUSTOM_TYPE = "engine:date-anchor";
-/**
- * Read the session's date anchor off the active branch: the nearest anchor entry NEWER than the nearest
- * compaction, honored only when it was written for that same segment. An anchor written by a leg whose
- * prefix predates a compaction that landed in between therefore reads as absent — the one rule that makes a
- * compaction re-anchor the date. An unreadable branch returns undefined (the leg renders today, writes nothing).
- */
-export declare function readDateAnchor(session: {
-    getBranch(): Promise<ReadonlyArray<SessionTreeEntry>>;
-}): Promise<DateAnchorRead | undefined>;
-/**
- * The anchor write a leg owes when it settles, or undefined: owed when prepare found no anchor for the segment
- * (the leg rendered today) or the model has since been told a newer date; never after an unreadable branch.
- * Best-effort — a lost write costs one re-rendered prefix or one repeated reminder next leg, never a wrong date.
- */
-export declare function owedDateAnchor(session: {
-    appendCustomEntry(customType: string, data?: unknown): Promise<string>;
-}, seat: {
-    legDate: string;
-    anchor: DateAnchorRead | undefined;
-} | undefined, state: {
-    announcedDate: string;
-} | undefined): (() => Promise<void>) | undefined;
 export {};

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

@@ -53,24 +53,26 @@ export async function loadAnnounceOnceLedger(session, checkpointMirror, onError)
         recovered = false;
         return undefined;
     });
-    const seed = checkpointMirror?.mcpFailed !== undefined || checkpointMirror?.advisories !== undefined ? checkpointMirror : entry;
+    const seed = checkpointMirror?.mcpFailed !== undefined || checkpointMirror?.advisories !== undefined || checkpointMirror?.advisor !== undefined ? checkpointMirror : entry;
     const listingSrc = checkpointMirror?.agents !== undefined || checkpointMirror?.skills !== undefined || checkpointMirror?.models !== undefined ? checkpointMirror : entry;
     let mcpFailed = (seed?.mcpFailed ?? []).map((f) => ({ ...f }));
     const advisories = new Set(seed?.advisories ?? []);
     let dirty = false;
+    const oncePerSession = (digest, deliver) => {
+        if (advisories.has(digest))
+            return;
+        deliver();
+        advisories.add(digest);
+        dirty = true;
+    };
     return {
         entry,
         recovered,
         onError: (err, ctx) => {
-            if (onError === undefined)
-                return;
-            const digest = warningDigest(err);
-            if (advisories.has(digest))
-                return;
-            onError(err, ctx);
-            advisories.add(digest);
-            dirty = true;
+            if (onError !== undefined)
+                oncePerSession(warningDigest(err), () => onError(err, ctx));
         },
+        oncePerSession,
         onErrorOncePerRunner: (err, ctx) => {
             if (onError === undefined)
                 return;
@@ -106,6 +108,7 @@ export async function loadAnnounceOnceLedger(session, checkpointMirror, onError)
             ...(listingSrc?.models !== undefined ? { models: [...listingSrc.models] } : {}),
             ...(mcpFailed.length > 0 ? { mcpFailed: mcpFailed.map((f) => ({ ...f })) } : {}),
             ...(advisories.size > 0 ? { advisories: withAnnounceDigests(undefined, [...advisories]) } : {}),
+            ...(seed?.advisor !== undefined ? { advisor: { ...seed.advisor } } : {}),
         }),
         settle: async (s, ref) => {
             if (advisories.size > 0)
@@ -119,6 +122,7 @@ export async function loadAnnounceOnceLedger(session, checkpointMirror, onError)
                 ...(ref.models !== undefined ? { models: ref.models } : {}),
                 ...(ref.mcpFailed !== undefined && ref.mcpFailed.length > 0 ? { mcpFailed: ref.mcpFailed } : {}),
                 ...(ref.advisories !== undefined && ref.advisories.length > 0 ? { advisories: ref.advisories } : {}),
+                ...(ref.advisor !== undefined ? { advisor: ref.advisor } : {}),
             })
                 .catch(() => undefined);
         },
@@ -131,43 +135,7 @@ export function serializeAnnouncedListings(ref) {
         ...(ref.models !== undefined ? { models: [...ref.models] } : {}),
         ...(ref.mcpFailed !== undefined ? { mcpFailed: ref.mcpFailed.map((f) => ({ ...f })) } : {}),
         ...(ref.advisories !== undefined ? { advisories: [...ref.advisories] } : {}),
+        ...(ref.advisor !== undefined ? { advisor: { ...ref.advisor } } : {}),
     };
     return Object.keys(out).length > 0 ? out : undefined;
 }
-export const DATE_ANCHOR_CUSTOM_TYPE = "engine:date-anchor";
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-function normalizeDateAnchor(v) {
-    if (typeof v !== "object" || v === null)
-        return undefined;
-    const { prefixDate, announcedDate, segment } = v;
-    if (typeof prefixDate !== "string" || !ISO_DATE.test(prefixDate) || typeof announcedDate !== "string" || !ISO_DATE.test(announcedDate))
-        return undefined;
-    if (segment !== null && (typeof segment !== "string" || segment.length > 200))
-        return undefined;
-    return { prefixDate, announcedDate, segment };
-}
-export async function readDateAnchor(session) {
-    let branch;
-    try {
-        branch = await session.getBranch();
-    }
-    catch {
-        return undefined;
-    }
-    let found;
-    let i = branch.length - 1;
-    for (; i >= 0 && branch[i].type !== "compaction"; i--) {
-        const e = branch[i];
-        if (found === undefined && e.type === "custom" && e.customType === DATE_ANCHOR_CUSTOM_TYPE)
-            found = normalizeDateAnchor(e.data);
-    }
-    const segment = i >= 0 ? branch[i].id : null;
-    return { current: found !== undefined && found.segment === segment ? { prefixDate: found.prefixDate, announcedDate: found.announcedDate } : undefined, segment };
-}
-export function owedDateAnchor(session, seat, state) {
-    const read = seat?.anchor;
-    if (read === undefined || state === undefined || read.current?.announcedDate === state.announcedDate)
-        return undefined;
-    const data = { prefixDate: seat.legDate, announcedDate: state.announcedDate, segment: read.segment };
-    return () => session.appendCustomEntry(DATE_ANCHOR_CUSTOM_TYPE, data).then(() => undefined, () => undefined);
-}

package/dist/core/runner/approval-feedback.js

@@ -9,16 +9,19 @@ export function refuseUnfitFeedback(twin) {
     if (words === undefined)
         return;
     if (twin.decision !== "allow") {
-        throw new CheckpointError("checkpoint.invalid_outcome", "resume carried `feedback` on a `deny` — feedback is the approving person's words on an `allow` (a denial's words are `reason`); refusing rather than dropping it silently, the checkpoint stays pending");
+        throw feedbackRefusal("resume carried `feedback` on a `deny` — feedback is the approving person's words on an `allow` (a denial's words are `reason`); refusing rather than dropping it silently, the checkpoint stays pending");
     }
     const byPerson = twin.hostDecision.decidedBy === "person";
     if (!byPerson) {
-        throw new CheckpointError("checkpoint.invalid_outcome", `resume carried \`feedback\` on a decide made by "${twin.hostDecision.decidedBy}" — feedback is delivered to the model as the user's own words, which only a person's decide can be; refusing rather than attributing a machine's text to the user, the checkpoint stays pending`);
+        throw feedbackRefusal(`resume carried \`feedback\` on a decide made by "${twin.hostDecision.decidedBy}" — feedback is delivered to the model as the user's own words, which only a person's decide can be; refusing rather than attributing a machine's text to the user, the checkpoint stays pending`);
     }
     if (sanitizeUntrustedText(words) !== words) {
-        throw new CheckpointError("checkpoint.invalid_outcome", sentinelTagRefusal("resume allow feedback"));
+        throw feedbackRefusal(sentinelTagRefusal("resume allow feedback"));
     }
 }
+function feedbackRefusal(message) {
+    return new CheckpointError("checkpoint.invalid_outcome", message, { field: "feedback" });
+}
 export function approvalWordsOf(outcome) {
     return outcome.gate === "policy_ask" && outcome.decision === "allow" ? writtenFeedback(outcome.feedback) : undefined;
 }

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

@@ -67,7 +67,7 @@ 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
+    /** The permission classifier's, a mod's and the advisor tool'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`. */

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

@@ -32,6 +32,7 @@
 import type { AgentTool } from "../../internal/harness.js";
 import type { TaskSpec } from "../types.js";
 import type { ToolSpec } from "../tool-spec.js";
+import type { ToolDeclarationCode } from "../governance-codes.js";
 import { type ToolCtxEnricher } from "../tools.js";
 declare const ROSTER_FACE: unique symbol;
 /** A roster entry as the snapshot minted it. The brand is private to this module and {@link rosterFaceOf} is the only
@@ -56,6 +57,12 @@ 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. */
+export declare function callerEngineContractProblem(face: RosterFace): {
+    code: ToolDeclarationCode;
+    message: string;
+} | undefined;
 /** 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 —

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

@@ -1,5 +1,7 @@
 import { TOOL_SPEC_MEMBERS, frozenExtra, frozenMember, newCopyState } from "../tool-spec-members.js";
 import { isDefineToolProduct, rebindDefineToolCtx } from "../tools.js";
+import { isCatalogContract } from "../tool-catalog-entries.js";
+import { contractOriginOf } from "../../prompt-assembly/tool-catalog.js";
 function specArmCanConstruct(t) {
     if (typeof t !== "object" || t === null)
         return false;
@@ -43,6 +45,13 @@ function refuseUnreadableEntry(index, entry, cause) {
     e.code = "config.tool_mount_denied";
     throw e;
 }
+const CATALOG_CONTRACT_FACES = new WeakSet();
+export function callerEngineContractProblem(face) {
+    const id = face.contract?.contractId;
+    if (typeof id !== "string" || contractOriginOf(id) !== "core" || CATALOG_CONTRACT_FACES.has(face))
+        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 rosterFaceOf(t, index) {
     if ((typeof t !== "object" && typeof t !== "function") || t === null)
         return t;
@@ -58,6 +67,8 @@ 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/classifier-ladder.d.ts

@@ -99,6 +99,28 @@ export declare function classifierSeatModel(args: {
     deps: Pick<RunnerDeps, "models" | "roles" | "tiers">;
     main: Model;
 }): ClassifierSeat;
+/**
+ * The catalog the seat is read off. The Runner expands tier bindings into the catalog at construction and
+ * keeps that expansion PRIVATE, so the engine reaches this seat with tier words already catalog keys — a host
+ * holding its own deps does not, and the tier-relative leg (which addresses the catalog BY tier word) would
+ * find nothing and answer `main_only`. Expanding here is idempotent: an existing catalog key SHADOWS the tier
+ * binding, so a second expansion over an expanded catalog changes no key.
+ *
+ * A binding naming a model the catalog no longer carries throws in the expansion — that is the BOOT error a
+ * deployment gets from the Runner's constructor, and a seat READ must not re-raise it: this function's whole
+ * posture is that a stale reference never fails the caller ({@link classifierSeatModel}'s two `catch` arms). Such a deployment
+ * cannot construct a Runner at all, so there is no engine answer to disagree with; the raw catalog is handed
+ * on and the ordinary fallbacks name the seat.
+ */
+export declare function normalizeSeatDeps<T extends Pick<RunnerDeps, "models" | "tiers">>(deps: T): T;
+/**
+ * The tier a model SITS on, as an index into `DEFAULT_TIER_ORDER` (0 = strongest): the LOWEST known tier whose
+ * expanded catalog key resolves to the same route as `model`. Read off a catalog {@link normalizeSeatDeps} expanded.
+ * The lowest, because a key synthesised for an unbound tier falls DOWN to the next bound one, so a model's lowest
+ * tier is the tier it was bound to. `undefined` when the deployment declares no tiers, or the model is on none.
+ * The one tier reading: the classifier seat and the advisor pairing both read it.
+ */
+export declare function tierIndexOf(deps: Pick<RunnerDeps, "models" | "tiers">, model: Model): number | undefined;
 /**
  * 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,
@@ -160,7 +182,7 @@ export interface ClassifierUnavailableStation {
  * 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 — CC 2.1.259 `MU`: spell off,
+ * 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.
@@ -194,9 +216,9 @@ export type ClassifierSeatRequest = typeof CLASSIFIER_OFF_SEAT | typeof CLASSIFI
  */
 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
+ * The user-message TAIL of each attempt — the reference's classifier suffixes: 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`)
+ * the thinking-stage suffix (`Uns`: think in `<thinking>` first, then answer). The base prompt
  * 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
@@ -209,7 +231,7 @@ export declare const CLASSIFIER_ATTEMPT_SUFFIX: {
 /** 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,
+ * 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.
@@ -243,7 +265,7 @@ export declare function classifierReplyVerdictText(reply: AssistantMessage): str
  * ({@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
+ * (CC's refusal arm). The reference 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.
  */

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

@@ -44,7 +44,7 @@ export function classifierSeatModel(args) {
         return { model: main, defaulted: "main_only" };
     }
 }
-function normalizeSeatDeps(deps) {
+export function normalizeSeatDeps(deps) {
     if (deps.tiers === undefined)
         return deps;
     try {
@@ -54,20 +54,21 @@ function normalizeSeatDeps(deps) {
         return deps;
     }
 }
-function tierBelowMain(deps, main) {
+export function tierIndexOf(deps, model) {
     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;
-        }
+    for (let i = DEFAULT_TIER_ORDER.length - 1; i >= 0; i--) {
+        const m = deps.models[DEFAULT_TIER_ORDER[i]];
+        if (m !== undefined && sameRouteQuietly(m, model))
+            return i;
     }
-    if (mainTier < 0)
+    return undefined;
+}
+function tierBelowMain(deps, main) {
+    const mainTier = tierIndexOf(deps, main);
+    if (mainTier === undefined)
         return undefined;
+    const bound = DEFAULT_TIER_ORDER.map((tier) => deps.models?.[tier]);
     for (let i = mainTier + 1; i < bound.length; i++) {
         const m = bound[i];
         if (m !== undefined && !sameRouteQuietly(m, main))

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

@@ -35,16 +35,20 @@ export declare function postureRestateOption(prepared: Prepared): Pick<MaybeComp
  * of every engine frame written at a boundary, the git frame's re-assert and the compaction itself: the run continues
  * and the failure is reported, `onError` phase `degraded`). Never throws.
  */
-export declare function appendOwedPosture(prepared: Pick<Prepared, "approvalPosture" | "toolRoster" | "hookIdentity" | "session" | "reminderMark" | "postureFrameRef" | "batchHaltRef">, ask: "always" | "on_change"): Promise<void>;
+export declare function appendOwedPosture(prepared: Pick<Prepared, "approvalPosture" | "toolRoster" | "hookIdentity" | "session" | "reminderMark" | "postureFrameRef" | "batchHaltRef" | "frameReceipts">, ask: "always" | "on_change"): Promise<void>;
 /** The declared output style's frame as one engine-marked reminder — the one spelling every site that states it directly
  *  (a resumed leg's continuation, a boundary a queued input continues) mints. */
 export declare function mintOutputStyleReminder(prepared: Pick<Prepared, "outputStyleFrame" | "reminderMark">): string | undefined;
+/** Is a frame of this source already on its way to the next request (a pending receipt)? The one reading, for every
+ *  collector that could state it again: the boundary bundle, the direct-write style lane and the posture writer. */
+export declare function frameCarried(ledger: Prepared["frameReceipts"], source: Prepared["frameReceipts"]["pending"][number]["source"]): boolean;
 /**
  * The turn boundary's direct writes, for a boundary a request can follow: the owed posture, and the output style when
- * the turn was text-final and queued work already guarantees the next request (`pendingInjectionCount`, both lanes). The
- * guarantee is read synchronously, at the call, before any await — a boundary with nothing queued returns the posture's own
- * promise, so it reaches no await the posture did not already have.
+ * the turn's tool results do not go back as the next request (`turnOwesRequest` false) and queued input already
+ * guarantees the next one (`pendingInjectionCount`, both lanes: what can continue a run), unless that request already
+ * carries it ({@link frameCarried}). Both frames keep the posture's halt rule. The guarantee is read synchronously, at
+ * the call, before any await — a boundary with nothing queued returns the posture's own promise.
  */
-export declare function appendBoundaryFrames(prepared: Pick<Prepared, "approvalPosture" | "toolRoster" | "hookIdentity" | "session" | "reminderMark" | "postureFrameRef" | "batchHaltRef" | "outputStyleFrame" | "harness">, turnHadToolCalls: boolean): Promise<void>;
+export declare function appendBoundaryFrames(prepared: Pick<Prepared, "approvalPosture" | "toolRoster" | "hookIdentity" | "session" | "reminderMark" | "postureFrameRef" | "batchHaltRef" | "outputStyleFrame" | "harness" | "frameReceipts">, turnOwesRequest: boolean): Promise<void>;
 /** Every post-compaction restatement the turn boundary registers, at one spread site. */
-export declare function compactionRestateOptions(prepared: Prepared): Pick<MaybeCompactOptions, "gitRestate" | "postureRestate">;
+export declare function compactionRestateOptions(prepared: Prepared): Pick<MaybeCompactOptions, "gitRestate" | "postureRestate" | "advisorRestate">;

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

@@ -4,6 +4,7 @@ import { mintSystemReminder } from "../reminder-mint.js";
 import { thrownText } from "../thrown-value.js";
 import { rosterEntryNamed } from "../tool-roster.js";
 import { sanitizeUntrustedText } from "../untrusted-text.js";
+import { appendAdvisorRestate } from "./advisor-instructions.js";
 import { gitRestateOption } from "./git-leg-delivery.js";
 import { attachmentEnvelopeTags } from "./turn-attachments.js";
 export function postureFactsOf(prepared) {
@@ -44,6 +45,8 @@ export function postureRestateOption(prepared) {
     };
 }
 export async function appendOwedPosture(prepared, ask) {
+    if (frameCarried(prepared.frameReceipts, "posture"))
+        return;
     const ref = prepared.postureFrameRef;
     const text = await owedPostureText(prepared, ask);
     if (text === undefined) {
@@ -88,11 +91,14 @@ async function appendOutputStyleRestate(prepared) {
         }
     }
 }
-export function appendBoundaryFrames(prepared, turnHadToolCalls) {
-    const styleOwed = prepared.outputStyleFrame !== undefined && !turnHadToolCalls && prepared.harness.pendingInjectionCount() > 0;
+export function frameCarried(ledger, source) {
+    return ledger.pending.some((r) => r.source === source);
+}
+export function appendBoundaryFrames(prepared, turnOwesRequest) {
+    const styleOwed = prepared.outputStyleFrame !== undefined && !turnOwesRequest && prepared.batchHaltRef.current === undefined && !frameCarried(prepared.frameReceipts, "output_style") && prepared.harness.pendingInjectionCount() > 0;
     const posture = appendOwedPosture(prepared, "on_change");
     return styleOwed ? posture.then(() => appendOutputStyleRestate(prepared)) : posture;
 }
 export function compactionRestateOptions(prepared) {
-    return { ...gitRestateOption(prepared), ...postureRestateOption(prepared) };
+    return { ...gitRestateOption(prepared), ...postureRestateOption(prepared), ...(prepared.advisorInstruction?.mounted === true ? { advisorRestate: () => appendAdvisorRestate(prepared) } : {}) };
 }

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

@@ -232,9 +232,9 @@ export interface DateAnchorRead {
 export interface FrameReceipt {
     /** The carrying message's exact text (its first text block) — the receipt's match key. */
     text: string;
-    /** Which frame this receipt settles. A boundary collector must not render a listing whose receipt is
-     *  still pending (the frame is queued, not yet in the transcript). */
-    source: "git_status" | "agent_listing" | "skills_listing" | "date_change" | "output_style" | "approval_feedback";
+    /** Which frame this receipt settles. No collector renders a frame whose receipt is still pending (the frame is on
+     *  its way, not yet in the transcript) — the one reading is `frameCarried` (compaction-restate.ts). */
+    source: "git_status" | "agent_listing" | "skills_listing" | "date_change" | "output_style" | "posture" | "approval_feedback" | "advisor_tool";
     /** Runs inside the `message_end` walk (synchronous, never awaited): advances the run-local record
      *  and parks any session write for the next serialization point. */
     commit: (entryId: string) => void;
@@ -1007,6 +1007,11 @@ export interface Prepared {
      *  calls themselves never pass through the recorded seam (they ride the separate compaction-brain
      *  wrapper), so the snapshot is never polluted by a summary request. */
     lastBrainContext: () => CompactionForkContext | undefined;
+    /** The same recorded request, unconditionally — the one write {@link lastBrainContext} also reads, minus its lossy-projection
+     *  exclusion: what the main lane last actually sent (the advisor's projection reads it). `undefined` until the first call. */
+    lastSentRequest: () => CompactionForkContext | undefined;
+    /** The leg's advisor-instructions seat (advisor-instructions.ts); absent when the leg neither mounts the advisor nor has told the model of it. */
+    advisorInstruction?: import("./advisor-instructions.js").AdvisorInstructionSeat;
     /** The post-compaction restore (`MaybeCompactOptions.workingFileAttachments.restore`): re-reads the candidates through
      *  the leg's one file reader under the run's synthetic-Read judge — the user attachment's own path read — deduplicated
      *  against the read state the summary leaves, and mints their attachment frames (`readCompactionRestore`); a file it
@@ -1030,7 +1035,7 @@ export interface Prepared {
      *  result from a stub hit whose original full transmission may already be summarized away. Present
      *  only with hands. */
     isDedupStubResult?: (resultText: string) => boolean;
-    /** Wired to `MaybeCompactOptions.onApplied` by every compaction lane (CC 220 clears readFileState at its
+    /** Wired to `MaybeCompactOptions.onApplied` by every compaction lane (the reference clears readFileState at its
      *  compaction landing site, @388663). Drops every read-state entry the summary took out of view
      *  (`readFileStateAfterSummary`); the restored files then re-register through their frames' own commits. Present
      *  only with hands. `preserveReadState` carries the files the context the summary leaves still shows — their
@@ -1159,7 +1164,7 @@ export interface Prepared {
     };
     /** G1 通告层续批 (CC `agent_listing_delta` parity) — the mounted delegation tool's agent-type roster
      *  (read off `ToolSpec.agentListing`, filled by createSubagentTool), plus the tool's mounted name for
-     *  the CC-verbatim headers. [c209-C]: this seam is now the roster's ONLY model-facing carrier —
+     *  the roster headers. [c209-C]: this seam is now the roster's ONLY model-facing carrier —
      *  the run loop delivers the initial full frame ON THE FIRST USER TURN (prompt-adjacent) and
      *  boundary drift deltas after. `models` (Q4, read off `ToolSpec.agentModels`) rides the initial
      *  frame's tail line. `seedAnnounced` = a durable-resume leg: the run loop seeds the producer's
@@ -1839,8 +1844,8 @@ export interface RunInternals {
      * `spec.systemPrompt ?? resolvedRole.systemPrompt ?? internals.defaultSystemPrompt` — so a deployment's
      * `roles.subagent.systemPrompt` / `roles.default.systemPrompt` preset still wins (pre-G1 semantics: an
      * unset child systemPrompt let the role preset apply; G1's first cut put SUBAGENT_PROMPT at spec level
-     * and silently shadowed the preset). Only when NO preset resolves does the lean SUBAGENT_PROMPT (CC 198
-     * general-purpose persona, pretty.js:419977) replace the full DEFAULT_SYSTEM_PROMPT constitution base.
+     * and silently shadowed the preset). Only when NO preset resolves does the lean SUBAGENT_PROMPT (general-purpose
+     * persona) replace the full DEFAULT_SYSTEM_PROMPT constitution base.
      * TRUSTED run-scoped channel (NOT a {@link TaskSpec} field), mirroring `insideFork`.
      */
     defaultSystemPrompt?: string;
@@ -2149,7 +2154,7 @@ export interface RunInternals {
      * Hands THIS run's notification injector back to the SPAWNER once the lane is
      * live (runtask calls it with its wrapped `injectTaskNotification`). The spawner stores it on the
      * child's registry handle so a parent/sibling SendMessage can deliver TO the RUNNING child at its
-     * next turn boundary (CC's in-memory `pendingMessages` pedestal, anchors/2.1.212
+     * next turn boundary (the in-memory `pendingMessages` pedestal,
      * messaging-runtime.md §2.5). The injector outlives its run safely: once this lane is over the frame
      * is routed to whatever run the SESSION has live, and only a session with no live run parks it
      * (PendingSessionNotifications) — exactly CC's durable-mailbox posture for an idle teammate (§2.4).
@@ -2529,7 +2534,6 @@ export interface RunState {
          *  requested id — surfaced on `turn_end.responseModel`, reset with the rest of the per-turn
          *  bookkeeping. Same shape as `turnStopReason`: last-message-wins, absent by default. */
         turnResponseModel: string | undefined;
-        lastTurnHadToolCalls: boolean;
         /** B15 三期使能:postToolBatch 的本回合聚集批(每回合边界消费并重置 — 回合语义,故归 turn)。 */
         toolBatch: PostToolBatchCall[];
     };

package/dist/core/runner/conversation-segment.d.ts

@@ -0,0 +1,28 @@
+import type { SessionTreeEntry } from "../../internal/harness-types.js";
+import type { DateAnchorRead } from "./contracts.js";
+/** The id of the active branch's latest compaction entry — the segment a fact is recorded for — or `null` before any. */
+export declare function conversationSegmentOf(branch: ReadonlyArray<SessionTreeEntry>): string | null;
+/** The custom-entry kind that carries the session's date anchor (engine-owned; never model-visible). */
+export declare const DATE_ANCHOR_CUSTOM_TYPE = "engine:date-anchor";
+/**
+ * Read the session's date anchor off the active branch: the nearest anchor entry NEWER than the nearest
+ * compaction, honored only when it was written for that same segment. An anchor written by a leg whose
+ * prefix predates a compaction that landed in between therefore reads as absent — the one rule that makes a
+ * compaction re-anchor the date. An unreadable branch returns undefined (the leg renders today, writes nothing).
+ */
+export declare function readDateAnchor(session: {
+    getBranch(): Promise<ReadonlyArray<SessionTreeEntry>>;
+}): Promise<DateAnchorRead | undefined>;
+/**
+ * The anchor write a leg owes when it settles, or undefined: owed when prepare found no anchor for the segment
+ * (the leg rendered today) or the model has since been told a newer date; never after an unreadable branch.
+ * Best-effort — a lost write costs one re-rendered prefix or one repeated reminder next leg, never a wrong date.
+ */
+export declare function owedDateAnchor(session: {
+    appendCustomEntry(customType: string, data?: unknown): Promise<string>;
+}, seat: {
+    legDate: string;
+    anchor: DateAnchorRead | undefined;
+} | undefined, state: {
+    announcedDate: string;
+} | undefined): (() => Promise<void>) | undefined;