@nathapp/nax-agent 0.91.7 → 0.91.8-canary.2

package/dist/native/session/session-summarizer.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The one summarizer every native compaction path shares (US-002).
+ *
+ * `sendTurn` built this closure inline until manual compaction needed the same
+ * call: same model, same clock, no tools, the same prompt asking for what a
+ * coding agent needs back — what was tried, what was rejected and why, the files
+ * touched — plus the same per-call budget and the same pricing. Two copies would
+ * have drifted on exactly the details that are invisible when they do (the
+ * thinking level, the rate card branch, the merge instruction), so the closure
+ * and the per-session resolution it depends on live here once.
+ *
+ * `resolveSessionModel` is the other half of that sharing: `sendTurn` and
+ * `compactHistory` must agree on the model, the rate card, the context window
+ * and the compaction settings, and they now do so by construction. The window
+ * and the settings are not used by the closure itself — they are what the caller
+ * hands the turn loop or the keep-budget maths, and resolving them alongside the
+ * client is what keeps one session's five facts from being assembled two ways.
+ *
+ * This module deliberately does NOT import a second site of `@nathapp/nax-ai`
+ * beyond the client types it is handed: the client arrives already built.
+ */
+import type { Client, ResolvedModel, ThinkingLevel } from "@nathapp/nax-ai";
+import type { Pricing } from "#src/cost/standard-types";
+import type { SessionHandle } from "#src/session/session-types";
+import type { TurnDeadline } from "#src/session/turn-deadline";
+import type { ResolvedCompaction } from "./compaction.ts";
+import type { NativeSessionState } from "./session.ts";
+import type { TurnDeps } from "./turn-types.ts";
+/**
+ * Everything one session's model call needs, resolved once per operation.
+ *
+ * `compaction` falls back to `DEFAULT_COMPACTION` rather than staying absent:
+ * an adapter whose open did not carry settings (an embedder that never set them)
+ * still answers "what is the keep budget" the way every other caller does. The
+ * automatic path's `TurnDeps.compaction` stays optional-and-absent for such a
+ * session — see the adapter's own note — because there "no settings" and
+ * "settings that disable compaction" must remain distinguishable.
+ */
+export interface SessionModelResolution {
+    readonly client: Client;
+    readonly model: ResolvedModel;
+    /** The provider half of the model id, as parsed (`authFields` needs it). */
+    readonly provider: string;
+    /** The request-side reasoning level the session's effort suffix translates to. */
+    readonly thinking: ThinkingLevel | undefined;
+    /** The rate card `priceCall` prices from: the config override, or the catalog. */
+    readonly rates: Pricing;
+    readonly pricingSource: "catalog-rates" | "config-override";
+    /** The window compaction counts against (`resolveContextWindow`). */
+    readonly contextWindow: number;
+    readonly compaction: ResolvedCompaction;
+    /** The provider-facing session id every call of this session carries. */
+    readonly sessionId: string;
+}
+/** Resolve the session's model facts. Throws on a malformed model id, as `sendTurn` always has. */
+export declare function resolveSessionModel(client: Client, state: NativeSessionState, handle: SessionHandle): Promise<SessionModelResolution>;
+/**
+ * What the summary call is asked for. Moved here unchanged from the adapter:
+ * the merge instruction is part of the summarizer's contract, not of the turn
+ * that happens to trigger it.
+ */
+export declare function summaryPrompt(previousSummary?: string): string;
+export interface SessionSummarizerInput {
+    readonly resolution: SessionModelResolution;
+    /** What is LEFT of the operation's budget, consulted per call. */
+    readonly deadline: TurnDeadline;
+    /**
+     * The operation's cancellation, already composed: for a turn that is the
+     * per-turn signal (caller + watchdog + deadline), for a manual compaction the
+     * facade's deadline and close signal. The per-call budget is fanned in here.
+     */
+    readonly signal: AbortSignal;
+}
+/** The `summarize` closure both `sendTurn` and `compactHistory` hand the compaction core. */
+export declare function createSessionSummarizer(input: SessionSummarizerInput): NonNullable<TurnDeps["summarize"]>;

package/dist/native/session/session-summarizer.js

@@ -0,0 +1,73 @@
+import { priceCall } from "#src/cost/core/index";
+import { _adapterDeps } from "../adapter-deps.js";
+import { buildRateCard, parseNativeModel, resolveContextWindow, toThinkingLevel } from "../models.js";
+import { nativeSessionId } from "../session-affinity.js";
+import { DEFAULT_COMPACTION } from "./compaction-settings.js";
+/** Resolve the session's model facts. Throws on a malformed model id, as `sendTurn` always has. */
+export async function resolveSessionModel(client, state, handle) {
+    const { provider, model, effort } = parseNativeModel(handle.modelDef?.model ?? "");
+    const resolved = await client.model(provider, model);
+    const { rates, source } = buildRateCard(client.pricing(resolved), handle.modelDef?.pricing);
+    return {
+        client,
+        model: resolved,
+        provider,
+        thinking: toThinkingLevel(effort),
+        rates,
+        pricingSource: source,
+        contextWindow: resolveContextWindow(handle.modelDef?.contextWindow, resolved.contextWindow),
+        compaction: state.compaction.get(handle.id) ?? DEFAULT_COMPACTION,
+        sessionId: nativeSessionId(handle.id),
+    };
+}
+/**
+ * What the summary call is asked for. Moved here unchanged from the adapter:
+ * the merge instruction is part of the summarizer's contract, not of the turn
+ * that happens to trigger it.
+ */
+export function summaryPrompt(previousSummary) {
+    const base = "Summarize the conversation above so it can be dropped from context. " +
+        "Record what was attempted, what was rejected and why, any decisions that still bind, " +
+        "and list the files read and the files modified. Be specific: this summary is the only " +
+        "memory of this work that survives.";
+    if (previousSummary === undefined)
+        return base;
+    return (`${base}\n\nAn earlier summary of still-older history follows. Merge it into your summary ` +
+        `rather than repeating or discarding it:\n\n${previousSummary}`);
+}
+/** The `summarize` closure both `sendTurn` and `compactHistory` hand the compaction core. */
+export function createSessionSummarizer(input) {
+    const { resolution, deadline, signal } = input;
+    return async (span, previousSummary) => {
+        const remainingMs = deadline.remainingMs();
+        const controller = new AbortController();
+        const timer = remainingMs !== undefined ? _adapterDeps.setTimeout(() => controller.abort(), remainingMs) : undefined;
+        // The per-call signal combines the operation's cancellation with this
+        // call's remaining budget, so a cancel ends the summary even mid-call.
+        const callSignal = AbortSignal.any([signal, controller.signal]);
+        try {
+            const res = await resolution.client.complete(resolution.model, {
+                messages: [...span, { role: "user", content: summaryPrompt(previousSummary) }],
+                sessionId: resolution.sessionId,
+                signal: callSignal,
+                // A summary restates the transcript; it does not need reasoning.
+                // "off", not an absent level: absent means the backend default,
+                // which on a model that cannot disable thinking is adaptive at
+                // effort high (#2686). The client clamps "off" to the least
+                // thinking such a model allows.
+                thinking: "off",
+            });
+            const { costUsd, resolvedRates } = priceCall(res.usage, resolution.rates);
+            return {
+                text: res.text,
+                usage: res.usage,
+                costUsd,
+                rates: resolvedRates,
+            };
+        }
+        finally {
+            if (timer !== undefined)
+                _adapterDeps.clearTimeout(timer);
+        }
+    };
+}

package/dist/native/session/transcript-identity.d.ts

@@ -4,6 +4,8 @@
  * store rather than only the file store.
  */
 import type { ConversationMessage } from "@nathapp/nax-ai";
+import type { SessionHandle } from "#src/session/session-types";
+import type { NativeSessionState } from "./session.ts";
 import type { TranscriptDoc } from "./transcript-types.ts";
 /**
  * Who may resume a transcript. `owner` is the op invocation (nax#1877); `model`
@@ -39,3 +41,13 @@ export declare function historyFromTranscript(doc: TranscriptDoc | null, identit
  * the file store writes it as-is, and nax's transcript bytes depend on that order.
  */
 export declare function transcriptDocFor(messages: readonly ConversationMessage[], identity: TranscriptIdentity): TranscriptDoc;
+/**
+ * The identity a session's transcript is loaded and saved under (US-002).
+ *
+ * One builder, because a turn's save and a manual compaction's save must claim
+ * exactly the same identity: the owner the invocation recorded (nax#1877) and
+ * the model that produced the history (nax#2150). A compaction that saved under
+ * a different identity would write a transcript the very next turn refuses to
+ * resume.
+ */
+export declare function transcriptIdentityFor(state: NativeSessionState, handle: SessionHandle): TranscriptIdentity;

package/dist/native/session/transcript-identity.js

@@ -79,3 +79,19 @@ export function transcriptDocFor(messages, identity) {
         messages: [...messages],
     };
 }
+/**
+ * The identity a session's transcript is loaded and saved under (US-002).
+ *
+ * One builder, because a turn's save and a manual compaction's save must claim
+ * exactly the same identity: the owner the invocation recorded (nax#1877) and
+ * the model that produced the history (nax#2150). A compaction that saved under
+ * a different identity would write a transcript the very next turn refuses to
+ * resume.
+ */
+export function transcriptIdentityFor(state, handle) {
+    return {
+        owner: state.transcriptOwners.get(handle.id),
+        model: transcriptModelIdentity(handle.modelDef?.model),
+        ...(state.carryHistoryAcrossModels.has(handle.id) ? { carryAcrossModels: true } : {}),
+    };
+}

package/dist/native/session/turn-compaction-step.d.ts

@@ -20,10 +20,10 @@
  * They share only the summarize-and-apply core below. The failure semantics
  * stay with the callers on purpose — see each function's catch.
  */
-import { type TranscriptMessage as NativeTranscriptMessage } from "./compaction.ts";
+import { type CompactionPlan, type TranscriptMessage as NativeTranscriptMessage } from "./compaction.ts";
 import type { LoopEventRegistry } from "./loop-events/index.ts";
 import { type TurnAccumulator } from "./turn-accumulator.ts";
-import type { TurnDeps } from "./turn-types.ts";
+import type { NativeSummaryResponse, TurnDeps } from "./turn-types.ts";
 /**
  * The compaction dependencies, with the three the step cannot run without
  * required. `TurnDeps` has them optional (absent disables compaction); the call
@@ -70,5 +70,33 @@ export interface OverflowCompactionArgs extends CompactionStepArgs {
      */
     readonly error: unknown;
 }
+interface AppliedSummary {
+    readonly messages: readonly NativeTranscriptMessage[];
+    readonly summary: NativeSummaryResponse;
+}
+/** What `summarizeAndApply` should use as the summary text. */
+interface SummarySource {
+    /**
+     * A `before_compaction` handler's replacement summary. When defined the
+     * summarizer call is skipped entirely, and the response below carries the
+     * handler's text with all-zero usage: no model call billed anything, so zero
+     * is honest (the same ruling as the transport-retry beat), and the beat the
+     * callers emit still resets the watchdog between apply and round trip.
+     */
+    readonly replacementSummary?: string;
+}
+/**
+ * The half both branches share: summarize the dropped span, then apply the
+ * summary to the transcript. A throw here is left to propagate — catching it is
+ * the proactive caller's decision, not this function's.
+ *
+ * Exported (US-002) because manual compaction is that same half: it plans with
+ * the same `prepareCompaction`, summarizes the same span with the same closure,
+ * and must not grow a second copy of the images-as-notes step. Its one
+ * difference — where the summary lands — is applied to the returned array by
+ * `applyManualCompaction`.
+ */
+export declare function summarizeAndApply(messages: readonly NativeTranscriptMessage[], plan: CompactionPlan, deps: CompactionStepDeps, source?: SummarySource): Promise<AppliedSummary>;
 export declare function runProactiveCompaction(args: CompactionStepArgs): Promise<CompactionStepResult>;
 export declare function runOverflowCompaction(args: OverflowCompactionArgs): Promise<CompactionStepResult>;
+export {};

package/dist/native/session/turn-compaction-step.js

@@ -28,8 +28,14 @@ import { usageBeat } from "./turn-accumulator.js";
  * The half both branches share: summarize the dropped span, then apply the
  * summary to the transcript. A throw here is left to propagate — catching it is
  * the proactive caller's decision, not this function's.
+ *
+ * Exported (US-002) because manual compaction is that same half: it plans with
+ * the same `prepareCompaction`, summarizes the same span with the same closure,
+ * and must not grow a second copy of the images-as-notes step. Its one
+ * difference — where the summary lands — is applied to the returned array by
+ * `applyManualCompaction`.
  */
-async function summarizeAndApply(messages, plan, deps, source = {}) {
+export async function summarizeAndApply(messages, plan, deps, source = {}) {
     const summary = source.replacementSummary !== undefined
         ? { text: source.replacementSummary, usage: { inputTokens: 0, outputTokens: 0 }, costUsd: 0 }
         : await deps.summarize(imagesAsNotes(plan.toSummarize), plan.previousSummary);

package/dist/native/session/turn-loop-round-trip.js

@@ -263,6 +263,34 @@ async function dispatchToolBatch(state, params, toolCalls) {
     }
     return { shouldBreak: false };
 }
+/**
+ * US-001: the pending steers, as the transcript messages they become. A steer
+ * is an ordinary user message — it persists and replays — so the loop appends
+ * it exactly as it appends a `before_turn_end` followUp.
+ */
+function steerMessages(steers) {
+    const texts = steers?.take() ?? [];
+    return texts.map((text) => ({ role: "user", content: text }));
+}
+/**
+ * US-001, round boundary: a steer accepted while a round ran joins the
+ * transcript before the next request, after that round's tool results. Two
+ * consecutive user messages (the tool results, then the steer) is intentional:
+ * the compaction path already produces that order and nax-ai passes it to the
+ * provider unchanged.
+ *
+ * Only a turn that has already run a round trip is a boundary — the first
+ * iteration IS the prompt — and never an aborted one: a cancelled turn's
+ * transcript records what happened, not what was typed as it went.
+ */
+function injectSteers(state, params) {
+    if (state.roundTrips === 0 || params.deps.signal?.aborted === true)
+        return;
+    const injected = steerMessages(params.opts.steers);
+    if (injected.length === 0)
+        return;
+    state.messages = [...state.messages, ...injected];
+}
 /**
  * Deliberately unbounded by COUNT of varied calls. A coding agent working a
  * story is bounded by wall clock (deps.deadline), by the idle watchdog, and
@@ -279,6 +307,10 @@ export async function runRoundTripLoop(state, params) {
             state.timedOut = true;
             break;
         }
+        // US-001: after the deadline check, so a steer typed into a turn with no
+        // round left is never appended, and before compaction, so the steer is part
+        // of what the compaction estimate sees.
+        injectSteers(state, params);
         const { summarizeFailed } = await maybeCompact(state, params);
         const toolCalls = await runModelRoundTrip(state, params, summarizeFailed);
         if (toolCalls === undefined)
@@ -301,30 +333,52 @@ export async function runRoundTripLoop(state, params) {
  * at MAX_FOLLOW_UPS_PER_TURN.
  */
 export async function runTurnEndPhase(state, params) {
-    const stopped = params.spinFlags.stopped || params.invalidCallBudget.exceeded || state.timedOut;
+    const stoppedAtDispatch = params.spinFlags.stopped || params.invalidCallBudget.exceeded || state.timedOut;
     const turnEnd = await params.loopEvents.dispatch("before_turn_end", {
         messages: state.messages,
         roundTrips: state.roundTrips,
         ended: "completed",
-        stopped,
+        // What the handler sees is the state it fired on, not what the dispatch
+        // itself went on to spend.
+        stopped: stoppedAtDispatch,
         followUpsSoFar: state.followUpsSoFar,
     });
-    if (stopped || state.followUpsSoFar >= MAX_FOLLOW_UPS_PER_TURN) {
-        if (turnEnd.followUp !== undefined) {
-            getSafeLogger()?.warn("native-loop-events", "before_turn_end followUp ignored", {
-                sessionName: params.handle.id,
-                ...(stopped ? { reason: "stopped" } : { reason: "cap", cap: MAX_FOLLOW_UPS_PER_TURN }),
-            });
-        }
-        return { action: "break" };
+    // The dispatch awaits, so the budget can run out while a handler works. A
+    // continuation planned from the pre-dispatch state would then be a round trip
+    // the very next deadline check refuses: the injection would sit in the
+    // transcript having never been sent (US-001 AC-18), and a steer in it would
+    // resolve `true` for a turn that never used it. So the phase re-reads the
+    // deadline — and marks the turn timed out exactly as the round-boundary check
+    // does — before it decides anything.
+    if (!stoppedAtDispatch && params.deps.deadline?.expired() === true)
+        state.timedOut = true;
+    const stopped = stoppedAtDispatch || state.timedOut;
+    // US-001: a steer accepted while the last round ran has no round boundary
+    // left to wait for, so it continues the turn from here — unless the turn was
+    // STOPPED (a breaker, or the budget, ended it on purpose; resurrecting it
+    // would reopen the loop the breaker exists to close) or its signal fired. The
+    // signal is re-read here too: it is checked AFTER the dispatch for the same
+    // reason as the deadline.
+    const steered = stopped || params.deps.signal?.aborted === true ? [] : steerMessages(params.opts.steers);
+    const capped = state.followUpsSoFar >= MAX_FOLLOW_UPS_PER_TURN;
+    const followUp = stopped || capped ? undefined : turnEnd.followUp;
+    if (followUp === undefined && turnEnd.followUp !== undefined) {
+        getSafeLogger()?.warn("native-loop-events", "before_turn_end followUp ignored", {
+            sessionName: params.handle.id,
+            ...(stopped ? { reason: "stopped" } : { reason: "cap", cap: MAX_FOLLOW_UPS_PER_TURN }),
+        });
     }
-    if (turnEnd.followUp === undefined)
+    // The cap gates the followUp ONLY: a steer is the person's own input, not a
+    // handler's injection, so it does not spend the followUp budget.
+    if (steered.length === 0 && followUp === undefined)
         return { action: "break" };
-    // Honoured: the user message enters the array and the outer loop
-    // re-enters the round-trip loop — each injection counts as its own
-    // round trip through the normal loop, and the turn's result is NOT
-    // built here.
-    const messages = [...state.messages, { role: "user", content: turnEnd.followUp }];
+    // Honoured: the user messages enter the array in the order they were typed —
+    // steers first, then the handler's followUp — and the outer loop re-enters
+    // the round-trip loop; each injection counts as its own round trip through
+    // the normal loop, and the turn's result is NOT built here.
+    const messages = [...state.messages, ...steered];
+    if (followUp !== undefined)
+        messages.push({ role: "user", content: followUp });
     // The continuation must earn its own clean exit, and a reprieved stop's
     // terminal-round-trip snapshot does not carry into it — the breaker's
     // own cumulative, session-lifetime counters (nax#2047) still enforce.
@@ -334,7 +388,7 @@ export async function runTurnEndPhase(state, params) {
         state: {
             ...state,
             messages,
-            followUpsSoFar: state.followUpsSoFar + 1,
+            followUpsSoFar: state.followUpsSoFar + (followUp !== undefined ? 1 : 0),
             completedNormally: false,
         },
     };

package/dist/native/session/turn-loop.js

@@ -26,7 +26,7 @@ import { createLoopEventRegistry } from "./loop-events/index.js";
 import { registerBuiltinLoopHandlers } from "./loop-handlers.js";
 import { sessionAnchorFor, sessionTranscriptFor } from "./session.js";
 import { codingToolsToDefinitions, toToolDefinitions } from "./tool-mapping.js";
-import { historyFromTranscript, transcriptDocFor, transcriptModelIdentity, } from "./transcript-identity.js";
+import { historyFromTranscript, transcriptDocFor, transcriptIdentityFor, } from "./transcript-identity.js";
 import { createTurnAccumulator } from "./turn-accumulator.js";
 import { dispatchTurnEndOnError } from "./turn-end-event.js";
 import { createTurnEventEmitter } from "./turn-event-emitter.js";
@@ -142,11 +142,7 @@ export async function runNativeTurn(handle, prompt, opts, deps) {
     // nax#2150 (P3 spec 8.3): so does a recorded different model — the loop
     // applies that guarantee to every store's document (historyFromTranscript),
     // whatever the session layer above decided.
-    const transcriptIdentity = {
-        owner: deps.sessionState.transcriptOwners.get(handle.id),
-        model: transcriptModelIdentity(handle.modelDef?.model),
-        ...(deps.sessionState.carryHistoryAcrossModels.has(handle.id) ? { carryAcrossModels: true } : {}),
-    };
+    const transcriptIdentity = transcriptIdentityFor(deps.sessionState, handle);
     let messages = [
         ...historyFromTranscript(await store.load(handle.id), transcriptIdentity, handle.id),
     ];

package/dist/native/session-adapter.d.ts

@@ -6,6 +6,7 @@
  * complete()) — nax owns the conversation because nax-ai's client is
  * stateless (ADR-027 section 10, ADR-028).
  */
+import type { CompactResult } from "#src/session/agent-session-types";
 import { type AgentSessionAdapter, type OpenSessionOpts, type SendTurnOpts, type SessionHandle, type TurnResult } from "#src/session/session-types";
 import { type NativeCatalogOverrides } from "./client.ts";
 import { type CredentialSource } from "./credentials/session-source.ts";
@@ -57,6 +58,24 @@ export declare class NativeSessionAdapter implements AgentSessionAdapter {
     /** Resolve the current handle's model; absent input metadata is text-only. */
     imageInput(handle: SessionHandle): Promise<boolean>;
     sendTurn(handle: SessionHandle, prompt: string, opts: SendTurnOpts): Promise<TurnResult>;
+    /**
+     * US-002: compact the stored history on demand, for a person who is done with
+     * an exploration and starting the next one.
+     *
+     * The whole budget this call gets is the facade's: its signal aborts on the
+     * session's turn deadline or on close, and this method only adds the same
+     * per-call ceiling a turn's model calls carry. The transcript is loaded,
+     * planned against and saved by `compactHistory` (session/manual-compaction.ts);
+     * this method supplies what it cannot reach for itself — the session's client,
+     * its state, and a deadline.
+     *
+     * A missing timeout entry falls back to the turn default WITHOUT a warning,
+     * unlike `sendTurn`: the facade always arms its own deadline first, so a
+     * missing entry is not the unbounded degradation the turn's warning names.
+     */
+    compactHistory(handle: SessionHandle, opts: {
+        signal: AbortSignal;
+    }): Promise<CompactResult>;
     closeSession(handle: SessionHandle): Promise<void>;
     /**
      * Run teardown addresses a session the process no longer has a handle for,

package/dist/native/session-adapter.js

@@ -16,13 +16,14 @@ import { _clientDeps, getNativeClient } from "./client.js";
 import { createSessionCredentialStore } from "./credentials/session-source.js";
 import { toAdapterFailure } from "./errors.js";
 import { billedOnFailure } from "./failed-round-trip-spend.js";
-import { buildRateCard, NATIVE_AGENT, parseNativeModel, resolveContextWindow, toThinkingLevel } from "./models.js";
+import { NATIVE_AGENT, parseNativeModel } from "./models.js";
 import { createInstructionInteraction } from "./session/instruction-interaction.js";
+import { compactHistory as compactStoredHistory } from "./session/manual-compaction.js";
 import { closeNativeSession, createNativeSessionState, markNativeTurnOutcome, openNativeSession, systemFieldFor, } from "./session/session.js";
+import { createSessionSummarizer, resolveSessionModel } from "./session/session-summarizer.js";
 import { buildNativeStreamEvent } from "./session/turn-events.js";
 import { runNativeTurn } from "./session/turn-loop.js";
 import { readNativeTurnFailureUsage } from "./session/turn-types.js";
-import { nativeSessionId } from "./session-affinity.js";
 import { streamComplete } from "./stream-complete.js";
 /**
  * Fallback whole-turn budget when a session's timeout entry is missing.
@@ -33,16 +34,6 @@ import { streamComplete } from "./stream-complete.js";
  * apply. Bounded-and-logged beats unbounded-and-quiet.
  */
 const FALLBACK_TURN_TIMEOUT_SECONDS = 3600;
-function summaryPrompt(previousSummary) {
-    const base = "Summarize the conversation above so it can be dropped from context. " +
-        "Record what was attempted, what was rejected and why, any decisions that still bind, " +
-        "and list the files read and the files modified. Be specific: this summary is the only " +
-        "memory of this work that survives.";
-    if (previousSummary === undefined)
-        return base;
-    return (`${base}\n\nAn earlier summary of still-older history follows. Merge it into your summary ` +
-        `rather than repeating or discarding it:\n\n${previousSummary}`);
-}
 /**
  * US-003: the per-turn inputs the adapter forwards verbatim into `TurnDeps`:
  * the plugin-contributed loop handlers and the facts their handlers read, plus
@@ -153,18 +144,23 @@ export class NativeSessionAdapter {
         return resolved.input?.includes("image") === true;
     }
     async sendTurn(handle, prompt, opts) {
-        const { provider, model, effort } = parseNativeModel(handle.modelDef?.model ?? "");
-        const thinking = toThinkingLevel(effort);
         const client = await this.client();
-        const resolved = await client.model(provider, model);
+        // US-002: the model, rate card, window, settings and session id come from
+        // the same resolution manual compaction uses, so the two cannot disagree
+        // about what this session is.
+        const sessionModel = await resolveSessionModel(client, this.state, handle);
+        const { rates, pricingSource, contextWindow, thinking, provider, sessionId } = sessionModel;
+        const resolved = sessionModel.model;
         // Refuse before runNativeTurn: its error path deliberately saves history.
         assertImageInput(handle, resolved, opts.images);
-        const contextWindow = resolveContextWindow(handle.modelDef?.contextWindow, resolved.contextWindow);
         this.state.repositoryInstructions
             .get(handle.id)
             ?.setContextBudget(contextWindow, this.state.systemPrompts.get(handle.id));
-        const catalog = client.pricing(resolved);
-        const { rates, source: pricingSource } = buildRateCard(catalog, handle.modelDef?.pricing);
+        // Read BEFORE the turn: an absent setting must stay absent in TurnDeps, so
+        // "this session recorded none" and "recorded settings that disable
+        // compaction" stay distinguishable for the loop. The fallback the
+        // resolution applies is the manual path's keep budget, nothing more.
+        const recordedCompaction = this.state.compaction.get(handle.id);
         const storedTimeoutSeconds = this.state.timeouts.get(handle.id);
         if (storedTimeoutSeconds === undefined) {
             getSafeLogger()?.warn("native-adapter", "session has no recorded timeout; falling back to the default budget", {
@@ -173,15 +169,12 @@ export class NativeSessionAdapter {
             });
         }
         const timeoutSeconds = storedTimeoutSeconds ?? FALLBACK_TURN_TIMEOUT_SECONDS;
-        // Keyed on the session, so every turn of one conversation carries the same
-        // id and the provider can keep its cache warm across them.
-        const sessionId = nativeSessionId(handle.id);
         // S3-4: the session's system prompt (facade `instructions`), or `{}`.
         // Resolved here so the `complete` closure spreads it without a branch.
         const instructionInteraction = createInstructionInteraction(this.state.repositoryInstructions.get(handle.id), opts.interactionHandler);
         // One budget for the whole turn, not one per round-trip. Created here
         // because this is where `timeoutSeconds` is known; consulted by the loop.
-        const deadline = createTurnDeadline(timeoutSeconds);
+        const deadline = createTurnDeadline(timeoutSeconds, () => _adapterDeps.now());
         const hooks = this.state.streamHooks.get(handle.id);
         // One callId per turn, mirroring SpawnAcpSession.prompt(). `runId` is
         // backfilled by the runtime's forwarding closure, which is the only place
@@ -239,9 +232,7 @@ export class NativeSessionAdapter {
                 sessionState: this.state,
                 deadline,
                 contextWindow,
-                ...(this.state.compaction.get(handle.id) !== undefined
-                    ? { compaction: this.state.compaction.get(handle.id) }
-                    : {}),
+                ...(recordedCompaction !== undefined ? { compaction: sessionModel.compaction } : {}),
                 ...(this.state.transportRetry.get(handle.id) !== undefined
                     ? { transportRetry: this.state.transportRetry.get(handle.id) }
                     : {}),
@@ -270,45 +261,7 @@ export class NativeSessionAdapter {
                 onActivity: (activity) => {
                     hooks?.onStreamActivity?.(buildNativeStreamEvent(eventBase, activity, Date.now()));
                 },
-                summarize: async (span, previousSummary) => {
-                    // Same model, same clock, no tools. The prompt asks for what a coding
-                    // agent needs back: what was tried, what was rejected and why, and the
-                    // files touched -- without them the agent re-reads what it already read.
-                    const remainingMs = deadline.remainingMs();
-                    const controller = new AbortController();
-                    const timer = remainingMs !== undefined ? _adapterDeps.setTimeout(() => controller.abort(), remainingMs) : undefined;
-                    // US-002: the per-call signal still combines with the per-turn signal
-                    // (watchdog + deadline + caller), so a turn cancel ends the summary
-                    // even mid-call. The per-call timer is the additional budget on top.
-                    const signal = AbortSignal.any(opts.signal !== undefined
-                        ? [opts.signal, controller.signal, turnController.signal, deadlineController.signal]
-                        : [controller.signal, turnController.signal, deadlineController.signal]);
-                    try {
-                        const res = await client.complete(resolved, {
-                            messages: [...span, { role: "user", content: summaryPrompt(previousSummary) }],
-                            sessionId,
-                            signal,
-                            // A summary restates the transcript; it does not need reasoning.
-                            // "off", not an absent level: absent means the backend default,
-                            // which on a model that cannot disable thinking is adaptive at
-                            // effort high (#2686). The client clamps "off" to the least
-                            // thinking such a model allows.
-                            thinking: "off",
-                        });
-                        const summaryUsage = res.usage;
-                        const { costUsd, resolvedRates } = priceCall(summaryUsage, rates);
-                        return {
-                            text: res.text,
-                            usage: summaryUsage,
-                            costUsd,
-                            rates: resolvedRates,
-                        };
-                    }
-                    finally {
-                        if (timer !== undefined)
-                            _adapterDeps.clearTimeout(timer);
-                    }
-                },
+                summarize: createSessionSummarizer({ resolution: sessionModel, deadline, signal: turnSignal }),
                 complete: async (messages, tools, requestOptions, onDelta) => {
                     // The controller is armed with what is LEFT of the turn, so N
                     // round-trips can no longer add up to N x timeoutSeconds. Still
@@ -430,6 +383,31 @@ export class NativeSessionAdapter {
         // so the stamp is read here, after the loop.
         return { ...result, ...authFields(provider, this.ownStore) };
     }
+    /**
+     * US-002: compact the stored history on demand, for a person who is done with
+     * an exploration and starting the next one.
+     *
+     * The whole budget this call gets is the facade's: its signal aborts on the
+     * session's turn deadline or on close, and this method only adds the same
+     * per-call ceiling a turn's model calls carry. The transcript is loaded,
+     * planned against and saved by `compactHistory` (session/manual-compaction.ts);
+     * this method supplies what it cannot reach for itself — the session's client,
+     * its state, and a deadline.
+     *
+     * A missing timeout entry falls back to the turn default WITHOUT a warning,
+     * unlike `sendTurn`: the facade always arms its own deadline first, so a
+     * missing entry is not the unbounded degradation the turn's warning names.
+     */
+    async compactHistory(handle, opts) {
+        const timeoutSeconds = this.state.timeouts.get(handle.id) ?? FALLBACK_TURN_TIMEOUT_SECONDS;
+        return compactStoredHistory({
+            state: this.state,
+            handle,
+            client: await this.client(),
+            deadline: createTurnDeadline(timeoutSeconds, () => _adapterDeps.now()),
+            signal: opts.signal,
+        });
+    }
     closeSession(handle) {
         // The adapter interface has no failure signal, so the verdict comes from the
         // session's last turn (markNativeTurnOutcome) rather than from this call.