tinker-agent 1.9.0 → 1.10.1

package/src/cli/public-config-contract.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { rgPath } from "@vscode/ripgrep";
+import { parseModelApi, type ModelApi } from "../model/model-api";
 
 export type PublicConfigValueKind = "non-empty-string" | "positive-integer" | "boolean";
 
@@ -39,6 +40,16 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     section: "model",
     description: "Model name used when model profiles are not configured.",
   }),
+  publicField({
+    name: "TINKER_API",
+    valueKind: "non-empty-string",
+    requiredIn: "never",
+    appliesIn: "env-mode",
+    defaultValue: "chat-completions",
+    secret: false,
+    section: "model",
+    description: 'Model API adapter: "chat-completions" or "responses".',
+  }),
   publicField({
     name: "TINKER_BASE_URL",
     valueKind: "non-empty-string",
@@ -46,7 +57,8 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     appliesIn: "env-mode",
     secret: false,
     section: "model",
-    description: "OpenAI-compatible Chat Completions API base URL.",
+    description:
+      "OpenAI-compatible API root URL; do not append /chat/completions or /responses.",
   }),
   publicField({
     name: "TINKER_API_KEY",
@@ -84,7 +96,8 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     defaultValue: false,
     secret: false,
     section: "model",
-    description: "Include provider reasoning content in the model response mapping.",
+    description:
+      "Replay provider reasoning_content in Chat Completions history; ignored by Responses.",
   }),
   publicField({
     name: "TINKER_STREAM",
@@ -94,7 +107,7 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     defaultValue: true,
     secret: false,
     section: "model",
-    description: "Use streaming Chat Completions transport.",
+    description: "Use streaming transport for the selected model API.",
   }),
   publicField({
     name: "TINKER_WEBFETCH_REFINE_MODEL",
@@ -229,7 +242,11 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
 
 export type ModelProfileField = {
   readonly name: string;
-  readonly valueKind: PublicConfigValueKind | "input-modalities" | "token-estimator";
+  readonly valueKind:
+    | PublicConfigValueKind
+    | "input-modalities"
+    | "reasoning"
+    | "token-estimator";
   readonly required: boolean;
   readonly defaultValue?: string | number | boolean | readonly string[];
   readonly secret: boolean;
@@ -248,12 +265,21 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     secret: false,
     description: "Provider model name.",
   }),
+  profileField({
+    name: "api",
+    valueKind: "non-empty-string",
+    required: false,
+    defaultValue: "chat-completions",
+    secret: false,
+    description: 'Model API adapter: "chat-completions" or "responses".',
+  }),
   profileField({
     name: "apiBase",
     valueKind: "non-empty-string",
     required: true,
     secret: false,
-    description: "OpenAI-compatible API base URL.",
+    description:
+      "OpenAI-compatible API root URL; do not append /chat/completions or /responses.",
   }),
   profileField({
     name: "apiKey",
@@ -277,13 +303,22 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     description:
       "Maximum output-token count supported by the model; must not exceed contextWindowTokens.",
   }),
+  profileField({
+    name: "reasoning",
+    valueKind: "reasoning",
+    required: false,
+    secret: false,
+    description:
+      "Provider-specific reasoning efforts and the default for each new session runtime.",
+  }),
   profileField({
     name: "includeReasoningContent",
     valueKind: "boolean",
     required: false,
     defaultValue: false,
     secret: false,
-    description: "Include provider reasoning content in response mapping.",
+    description:
+      "Replay provider reasoning_content in Chat Completions history; ignored by Responses.",
   }),
   profileField({
     name: "stream",
@@ -291,7 +326,7 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     required: false,
     defaultValue: true,
     secret: false,
-    description: "Use streaming Chat Completions transport.",
+    description: "Use streaming transport for the selected model API.",
   }),
   profileField({
     name: "inputModalities",
@@ -311,6 +346,35 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
   }),
 ]);
 
+export type ModelReasoningField = {
+  readonly name: string;
+  readonly valueKind: "non-empty-string" | "non-empty-string-array";
+  readonly required: true;
+  readonly secret: false;
+  readonly description: string;
+};
+
+function reasoningField<const T extends ModelReasoningField>(field: T): Readonly<T> {
+  return Object.freeze(field);
+}
+
+export const MODEL_REASONING_FIELDS = Object.freeze([
+  reasoningField({
+    name: "supportedEfforts",
+    valueKind: "non-empty-string-array",
+    required: true,
+    secret: false,
+    description: "Provider-supported effort values exposed by the /reasoning command.",
+  }),
+  reasoningField({
+    name: "defaultEffort",
+    valueKind: "non-empty-string",
+    required: true,
+    secret: false,
+    description: "Effort used whenever a session runtime is created or reopened.",
+  }),
+]);
+
 export type ModelTokenEstimatorField = {
   readonly name: string;
   readonly valueKind: PublicConfigValueKind | "literal-string" | "literal-number";
@@ -502,6 +566,7 @@ export type ParsedPublicEnvironment =
   | (ParsedCommonEnvironment & {
       readonly mode: "env";
       readonly modelName: string;
+      readonly api: ModelApi;
       readonly apiBase: string;
       readonly apiKey: string;
       readonly contextWindowTokens: number;
@@ -615,6 +680,7 @@ export function parsePublicEnvironment(
     ...common,
     mode,
     modelName,
+    api: parseModelApi(requiredStringValue(values, "TINKER_API"), "TINKER_API"),
     apiBase: requiredStringValue(values, "TINKER_BASE_URL"),
     apiKey: requiredStringValue(values, "TINKER_API_KEY"),
     contextWindowTokens: requiredNumberValue(values, "TINKER_CONTEXT_WINDOW_TOKENS"),

package/src/cli/run-runner.ts

@@ -16,6 +16,7 @@ import {
   createWebFetchRefiner,
   RUNTIME_INSTRUCTIONS,
 } from "./runner-dependencies";
+import { createReasoningEffortController } from "../model/reasoning-effort";
 import type { PublicToolingConfig } from "./public-config-contract";
 import { realpath } from "node:fs/promises";
 import { loadSkillCatalog } from "../skills/skill-loader";
@@ -51,10 +52,12 @@ export async function runOneShot(
       runtimeInstructions: RUNTIME_INSTRUCTIONS(workspaceRoot),
       projectInstructions,
     });
+    const reasoningEffort = createReasoningEffortController(config.reasoning);
     const modelClient = createRunnerModelClient(
       config,
       options.modelClient,
       options.env,
+      reasoningEffort,
     );
     session = await createRuntimeSession({
       selection: { mode: "new", sessionId: config.sessionId },
@@ -72,7 +75,7 @@ export async function runOneShot(
       presentationSinks: [new StdoutEventPrinter(stdout, stderr)],
       persistence:
         options.eventLogPath === false ? false : { eventLogPath: options.eventLogPath },
-      webFetchRefiner: createWebFetchRefiner(config, options.env),
+      webFetchRefiner: createWebFetchRefiner(config, options.env, reasoningEffort),
       toolingConfig: options.tooling,
       bashGuard: {
         mode: config.bashGuardMode,

package/src/cli/runner-dependencies.ts

@@ -2,6 +2,11 @@ import { renderRecallRetirementContract } from "../context/recall-retirement-con
 import { FakeModelClient } from "../model/fake-model-client";
 import type { ModelClient } from "../model/model-client";
 import { OpenAIChatModelClient } from "../model/openai-chat-model-client";
+import { OpenAIResponsesModelClient } from "../model/openai-responses-model-client";
+import {
+  createReasoningEffortController,
+  type ReasoningEffortController,
+} from "../model/reasoning-effort";
 import { createModelRefiner, type Refiner } from "../tools/web-fetch/refiner";
 import type { RunnerConfig } from "./config";
 
@@ -53,6 +58,8 @@ export function createModelClient(
   config: Pick<
     RunnerConfig,
     | "modelName"
+    | "api"
+    | "reasoning"
     | "includeReasoningContent"
     | "stream"
     | "contextBudget"
@@ -62,13 +69,19 @@ export function createModelClient(
     | "tokenEstimator"
   >,
   env: NodeJS.ProcessEnv = process.env,
+  reasoningEffort?: ReasoningEffortController,
 ): ModelClient {
+  const activeReasoningEffort =
+    reasoningEffort ?? createReasoningEffortController(config.reasoning);
   const fakeMode = env.TINKER_TEST_FAKE_MODEL;
   if (fakeMode !== undefined && fakeMode !== "") {
     return new FakeModelClient(fakeMode, {
       model: config.modelName,
       contextBudget: config.contextBudget,
       inputModalities: config.inputModalities,
+      ...(activeReasoningEffort === undefined
+        ? {}
+        : { reasoningEffort: activeReasoningEffort }),
       ...(config.tokenEstimator === undefined
         ? {}
         : { tokenEstimator: config.tokenEstimator }),
@@ -79,17 +92,26 @@ export function createModelClient(
     });
   }
 
-  return new OpenAIChatModelClient({
+  const common = {
     apiKey: config.apiKey,
     baseURL: config.apiBase,
-    includeReasoningContent: config.includeReasoningContent,
     model: config.modelName,
     stream: config.stream,
     contextBudget: config.contextBudget,
     inputModalities: config.inputModalities,
+    ...(activeReasoningEffort === undefined
+      ? {}
+      : { reasoningEffort: activeReasoningEffort }),
     ...(config.tokenEstimator === undefined
       ? {}
       : { tokenEstimator: config.tokenEstimator }),
+  };
+  if (config.api === "responses") {
+    return new OpenAIResponsesModelClient(common);
+  }
+  return new OpenAIChatModelClient({
+    ...common,
+    includeReasoningContent: config.includeReasoningContent,
   });
 }
 
@@ -97,16 +119,18 @@ export function createRunnerModelClient(
   config: Parameters<typeof createModelClient>[0],
   injected?: ModelClient,
   env?: NodeJS.ProcessEnv,
+  reasoningEffort?: ReasoningEffortController,
 ): ModelClient {
-  return injected ?? createModelClient(config, env);
+  return injected ?? createModelClient(config, env, reasoningEffort);
 }
 
 export function createWebFetchRefiner(
   config: Parameters<typeof createModelClient>[0],
   env?: NodeJS.ProcessEnv,
+  reasoningEffort?: ReasoningEffortController,
 ): Refiner {
   return createModelRefiner({
-    createModelClient: () => createModelClient(config, env),
+    createModelClient: () => createModelClient(config, env, reasoningEffort),
     contextBudget: config.contextBudget,
   });
 }

package/src/cli/tui-memory.ts

@@ -37,8 +37,12 @@ export async function initializeTuiMemory(input: {
         return createModelClient(
           {
             modelName: profile.model,
+            api: profile.api,
             apiKey: profile.apiKey,
             apiBase: profile.apiBase,
+            ...(profile.reasoning === undefined
+              ? {}
+              : { reasoning: profile.reasoning }),
             includeReasoningContent: profile.includeReasoningContent,
             stream: profile.stream,
             contextBudget: memoryConfig.contextBudget,

package/src/cli/tui-runner.tsx

@@ -48,6 +48,7 @@ import { createWorkspaceFileLister } from "../tui/workspace-file-search";
 import { clipboardWriterForEnvironment } from "../tui/clipboard";
 import { initializeTuiMemory } from "./tui-memory";
 import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
+import { createReasoningEffortController } from "../model/reasoning-effort";
 
 export type RunTuiOptions = {
   readonly publicConfig: ResolvedPublicConfig;
@@ -82,10 +83,12 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
       sessionId: SessionId,
       sink: EventSink & AssistantTextDeltaSink,
     ): Promise<RuntimeSession> => {
+      const reasoningEffort = createReasoningEffortController(sessionConfig.reasoning);
       const modelClient = createRunnerModelClient(
         sessionConfig,
         undefined,
         options.env,
+        reasoningEffort,
       );
       const projectInstructions = await loadProjectInstructions(workspaceRoot);
       const skillCatalog = await loadSkillCatalog({ workspaceRoot });
@@ -107,7 +110,11 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         skillCatalog,
         presentationSinks: [sink],
         assistantTextDeltaSink: sink,
-        webFetchRefiner: createWebFetchRefiner(sessionConfig, options.env),
+        webFetchRefiner: createWebFetchRefiner(
+          sessionConfig,
+          options.env,
+          reasoningEffort,
+        ),
         toolingConfig: options.publicConfig.tooling,
         enableTurnUndo: true,
         bashGuard: {

package/src/context/context-automation-policy.ts

@@ -1,5 +1,5 @@
 import { stableJsonStringify, sha256 } from "../model/model-request-preflight";
-import { RECALL_TOOL_DEFINITION } from "../tools/recall";
+import { RECALL_TOOL_DEFINITIONS } from "../tools/recall";
 import type { ToolDefinition } from "../tools/types";
 import type { StoredContextSurfaceV8 } from "./context-surface";
 import {
@@ -17,26 +17,26 @@ export const I4_ACTIVE_RECALL_QUALIFICATION = Object.freeze({
   policyVersion: "active-recall-qualification-policy-v1",
   policySha256: "77ca611594d4e9b7b5a597a3a33e35fcaaffae284dc2ac9953ce9a63cce1c009",
   positiveReportSha256:
-    "ef84dfee3fdefd7bbf1be2f1641bccc4a1aa06874b22172fecc03dfa2db840d6",
+    "e827e5e94171328bb2dd7fcaeff91881f04bdfc78361a45e2548da323229b02a",
   negativeReportSha256:
-    "c991980ae2824102174315c9b25c1e4affdbbd22aac320e1a254f2702ba3d1b4",
+    "ed379843aee0f193f398a4dff9a18ed338f0edab2cbaf9b628d0dfc402d925a4",
   resolvedModel: "deepseek-v4-flash",
   recallContractVersion: CURRENT_RECALL_RETIREMENT_CONTRACT_VERSION,
   recallContractSha256:
-    "c75108d351ed3223928ebeb52c7258a6f95033287a8e560fb5b2efff8e084c9b",
+    "3b6d1a452efea1db5920eb13542571b038667ef4f635551bea375bda6562a39f",
   recallToolDefinitionSha256:
-    "60caf87f313ea35e74e278ab8b30337cc8af1cc83d82d957a73857a764f3e3d9",
+    "e63ada7cdf9591d1e933cf5e190ea30586e02bbf73aeb5e648db449d75aae009",
   metrics: Object.freeze({
-    fullHistoryTaskSuccessRate: 1,
-    swapOnlyTaskSuccessRate: 1,
-    recallOnlyTaskSuccessRate: 0.9667,
-    recallOnlyActiveRecallRate: 0.9667,
-    recallOnlySearchGetSuccessRate: 0.3,
-    minimumCounterfactualGroupTaskSuccessRate: 0.8333,
-    invalidRecallCallsPerRecallOnlyTrial: 0.0333,
+    fullHistoryTaskSuccessRate: 0.9667,
+    swapOnlyTaskSuccessRate: 0.9667,
+    recallOnlyTaskSuccessRate: 1,
+    recallOnlyActiveRecallRate: 1,
+    recallOnlySearchGetSuccessRate: 0.3333,
+    minimumCounterfactualGroupTaskSuccessRate: 1,
+    invalidRecallCallsPerRecallOnlyTrial: 0,
     negativeUnnecessaryRecallRate: 0,
-    recallOnlyTokenRatioToFullHistory: 1.1555,
-    recallOnlyLatencyRatioToFullHistory: 1.365,
+    recallOnlyTokenRatioToFullHistory: 1.3739,
+    recallOnlyLatencyRatioToFullHistory: 1.207,
   }),
   passed: true,
 } as const);
@@ -80,13 +80,14 @@ export function selectContextAutomation(
   ) {
     return disabled("recall_contract_mismatch");
   }
-  const recall = input.surface.toolDefinitions.find(
-    (definition) => definition.name === "Recall",
+  const recallTools = input.surface.toolDefinitions.filter(
+    (definition) =>
+      definition.name === "RecallSearch" || definition.name === "RecallGet",
   );
   if (
-    recall === undefined ||
-    toolDefinitionHash(recall) !== evidence.recallToolDefinitionSha256 ||
-    toolDefinitionHash(RECALL_TOOL_DEFINITION) !== evidence.recallToolDefinitionSha256
+    recallTools.length !== 2 ||
+    toolDefinitionsHash(recallTools) !== evidence.recallToolDefinitionSha256 ||
+    toolDefinitionsHash(RECALL_TOOL_DEFINITIONS) !== evidence.recallToolDefinitionSha256
   ) {
     return disabled("recall_tool_mismatch");
   }
@@ -116,6 +117,6 @@ function disabled(
   });
 }
 
-function toolDefinitionHash(definition: ToolDefinition): string {
-  return sha256(stableJsonStringify(definition));
+function toolDefinitionsHash(definitions: readonly ToolDefinition[]): string {
+  return sha256(stableJsonStringify(definitions));
 }

package/src/context/context-manager.ts

@@ -1,7 +1,7 @@
 import { ContextBuilder } from "../agent/context-builder";
 import type { ContextMeter, ContextUsageSnapshot } from "../agent/context-meter";
-import type { SessionLedger } from "../agent/session-ledger";
-import type { RuntimeIdFactory } from "../ids/runtime-id";
+import type { AgentTurnLedger, SessionLedger } from "../agent/session-ledger";
+import type { RuntimeIdFactory, TurnId } from "../ids/runtime-id";
 import {
   CommittedPrefixAuditError,
   type CommittedPrefixAuditor,
@@ -45,17 +45,25 @@ import {
   PrefixRetirementPlanner,
   PrefixRetirementPlanningError,
   PrefixRetirementPlanStaleError,
+  type ActiveTurnBoundary,
+  type ClosedTurnBoundary,
   type PrefixRetirementPlan,
 } from "./prefix-retirement-planner";
 
 export type ContextCompactionTrigger =
   | { kind: "manual" }
-  | { kind: "runtime_pressure" }
+  | {
+      kind: "runtime_pressure";
+      activeTurn?: {
+        turnId: TurnId;
+        consumedThroughOrdinal: number;
+      };
+    }
   | { kind: "benchmark_forced"; targetTokens: number };
 
 export type ContextRetirementTrigger =
   | { kind: "manual" }
-  | { kind: "runtime_pressure" }
+  | { kind: "runtime_pressure"; activeTurnId?: TurnId }
   | { kind: "benchmark_forced"; targetTokens: number };
 
 export type ContextCompactionResult =
@@ -246,15 +254,32 @@ export class ContextManager {
     this.retirementPlanner = new PrefixRetirementPlanner(input.model);
   }
 
-  async compact(trigger: ContextCompactionTrigger): Promise<ContextCompactionResult> {
+  measureCurrent(
+    activeTurnId?: TurnId,
+    activeLedger?: AgentTurnLedger,
+  ): ContextUsageSnapshot {
+    assertActiveLedger(activeTurnId, activeLedger);
+    this.input.store.assertContextRevisionBoundary(activeTurnId);
+    const tools = this.input.tools();
+    const built = buildCurrentRequest(this.input.ledger, activeLedger, tools);
+    const prepared = this.input.model.prepare(built.request);
+    this.input.committedPrefixAuditor.audit(built.compiled.revisionId, prepared);
+    return this.input.contextMeter.measure(prepared);
+  }
+
+  async compact(
+    trigger: ContextCompactionTrigger,
+    activeLedger?: AgentTurnLedger,
+  ): Promise<ContextCompactionResult> {
+    assertActiveLedger(activeTurnId(trigger), activeLedger);
     const startedAt = performance.now();
     let built;
     let activePrepared;
     let activeUsage;
     const tools = this.input.tools();
     try {
-      this.input.store.assertContextRevisionIdle();
-      built = this.input.ledger.buildCommittedModelRequest(tools);
+      this.input.store.assertContextRevisionBoundary(activeTurnId(trigger));
+      built = buildCurrentRequest(this.input.ledger, activeLedger, tools);
       activePrepared = this.input.model.prepare(built.request);
       activeUsage = this.input.contextMeter.measure(activePrepared);
     } catch (error) {
@@ -274,6 +299,9 @@ export class ContextManager {
         tools,
         policy: swapOnlyPolicyV1,
         trigger: trigger.kind,
+        ...(trigger.kind === "runtime_pressure" && trigger.activeTurn !== undefined
+          ? { activeTurn: trigger.activeTurn }
+          : {}),
         ...(trigger.kind === "benchmark_forced"
           ? { forcedTargetTokens: trigger.targetTokens }
           : {}),
@@ -357,7 +385,7 @@ export class ContextManager {
       candidatePrepared = this.input.model.prepare(candidate.request);
       assertCandidatePrepared(activePrepared, candidatePrepared, plan);
 
-      const current = this.input.ledger.buildCommittedModelRequest(tools);
+      const current = buildCurrentRequest(this.input.ledger, activeLedger, tools);
       const currentPrepared = this.input.model.prepare(current.request);
       assertPlanBaseCurrent(plan, {
         active: current.compiled,
@@ -365,7 +393,7 @@ export class ContextManager {
         activeOverrides: current.activeOverrides,
         activePrepared: currentPrepared,
       });
-      this.input.store.assertContextRevisionIdle();
+      this.input.store.assertContextRevisionBoundary(activeTurnId(trigger));
     } catch (error) {
       throw managerError("validate", error);
     }
@@ -394,6 +422,9 @@ export class ContextManager {
           candidateCompiled.entries,
           plan.baseCanonicalThroughOrdinal,
         ),
+        ...(activeTurnId(trigger) === undefined
+          ? {}
+          : { activeTurnId: activeTurnId(trigger) }),
       });
     } catch (error) {
       throw managerError("commit", error);
@@ -402,6 +433,7 @@ export class ContextManager {
 
     const activationStartedAt = performance.now();
     try {
+      activeLedger?.activateContextSnapshot(this.input.store.loadContextSnapshot());
       this.input.contextMeter.startRevision({
         reason: "context_rebuilt",
         requestConfigHash: candidatePrepared.requestConfigHash,
@@ -454,19 +486,26 @@ export class ContextManager {
 
   async retirePrefix(
     trigger: ContextRetirementTrigger,
+    activeLedger?: AgentTurnLedger,
   ): Promise<ContextRetirementResult> {
+    assertActiveLedger(activeTurnId(trigger), activeLedger);
     const startedAt = performance.now();
     const tools = this.input.tools();
     let built;
     let activePrepared;
     let activeUsage;
-    let closedTurns;
+    let closedTurns: readonly ClosedTurnBoundary[];
+    let activeTurn: ActiveTurnBoundary | undefined;
     try {
-      this.input.store.assertContextRevisionIdle();
-      built = this.input.ledger.buildCommittedModelRequest(tools);
+      this.input.store.assertContextRevisionBoundary(activeTurnId(trigger));
+      built = buildCurrentRequest(this.input.ledger, activeLedger, tools);
       activePrepared = this.input.model.prepare(built.request);
       activeUsage = this.input.contextMeter.measure(activePrepared);
-      closedTurns = this.input.store.loadClosedTurnBoundaries();
+      const boundaries = this.input.store.loadRetirementBoundaries(
+        activeTurnId(trigger),
+      );
+      closedTurns = boundaries.closedTurns;
+      activeTurn = boundaries.activeTurn;
     } catch (error) {
       throw managerError("snapshot", error);
     }
@@ -480,6 +519,7 @@ export class ContextManager {
         activeOverrides: built.activeOverrides,
         canonical: built.canonical,
         closedTurns,
+        ...(activeTurn === undefined ? {} : { activeTurn }),
         activePrepared,
         activeUsage,
         tools,
@@ -547,7 +587,7 @@ export class ContextManager {
       candidatePrepared = this.input.model.prepare(candidate.request);
       assertRetirementCandidatePrepared(activePrepared, candidatePrepared, plan);
 
-      const current = this.input.ledger.buildCommittedModelRequest(tools);
+      const current = buildCurrentRequest(this.input.ledger, activeLedger, tools);
       const currentPrepared = this.input.model.prepare(current.request);
       assertRetirementPlanBaseCurrent(plan, {
         active: current.compiled,
@@ -557,7 +597,7 @@ export class ContextManager {
         canonical: current.canonical,
         activePrepared: currentPrepared,
       });
-      this.input.store.assertContextRevisionIdle();
+      this.input.store.assertContextRevisionBoundary(activeTurnId(trigger));
     } catch (error) {
       throw managerError("validate", error);
     }
@@ -586,6 +626,9 @@ export class ContextManager {
         nextActiveOverrideManifestSha256: plan.nextActiveOverrideManifestSha256,
         canonicalSequenceSha256: plan.canonicalSequenceSha256,
         renderedMessageSha256: plan.renderedMessageSha256,
+        ...(activeTurnId(trigger) === undefined
+          ? {}
+          : { activeTurnId: activeTurnId(trigger) }),
       });
     } catch (error) {
       throw managerError("commit", error);
@@ -594,6 +637,7 @@ export class ContextManager {
 
     const activationStartedAt = performance.now();
     try {
+      activeLedger?.activateContextSnapshot(this.input.store.loadContextSnapshot());
       this.input.contextMeter.startRevision({
         reason: "context_rebuilt",
         requestConfigHash: candidatePrepared.requestConfigHash,
@@ -739,3 +783,35 @@ function errorCode(error: unknown): string {
 function elapsedMs(startedAt: number): number {
   return Math.round((performance.now() - startedAt) * 100) / 100;
 }
+
+function activeTurnId(
+  trigger: ContextCompactionTrigger | ContextRetirementTrigger,
+): TurnId | undefined {
+  if (trigger.kind !== "runtime_pressure") {
+    return undefined;
+  }
+  if ("activeTurnId" in trigger) {
+    return trigger.activeTurnId;
+  }
+  return (trigger as Extract<ContextCompactionTrigger, { kind: "runtime_pressure" }>)
+    .activeTurn?.turnId;
+}
+
+function assertActiveLedger(
+  activeTurnId: TurnId | undefined,
+  activeLedger: AgentTurnLedger | undefined,
+): void {
+  if ((activeTurnId === undefined) !== (activeLedger === undefined)) {
+    throw new Error("Active context maintenance requires its active turn ledger.");
+  }
+}
+
+function buildCurrentRequest(
+  ledger: SessionLedger,
+  activeLedger: AgentTurnLedger | undefined,
+  tools: readonly ToolDefinition[],
+) {
+  return activeLedger === undefined
+    ? ledger.buildCommittedModelRequest(tools)
+    : activeLedger.buildModelRequest(tools);
+}

package/src/context/context-policy.ts

@@ -1,7 +1,6 @@
 export const swapOnlyPolicyV1 = Object.freeze({
   version: "swap-only-v1",
   minimumObservationBytes: 8 * 1_024,
-  protectedRecentTurnCount: 8,
   targetInputRatio: 0.3,
 } as const);
 
@@ -9,7 +8,6 @@ export type SwapOnlyPolicyV1 = typeof swapOnlyPolicyV1;
 
 export const recallFirstRetirementPolicyV1 = Object.freeze({
   version: "recall-first-retirement-v1",
-  protectedRecentTurnCount: 8,
   targetInputRatio: 0.3,
 } as const);
 

package/src/context/context-swap-renderer.ts

@@ -73,7 +73,7 @@ export class ContextSwapRenderer {
       `contentSha256=${message.contentSha256}`,
       `tool=${stableJsonStringify(compactExternalString(message.name))}`,
       `metadata=${metadata}`,
-      "historical=Use Recall get with source to recover the original observation.",
+      "historical=Use RecallGet with source to recover the original observation.",
       `current=${currentGuidance(raw.kind)}`,
     ].join("\n");
     const originalBytes = utf8Bytes(message.content);