@noetic-tools/context 1.1.0 → 1.2.1

package/dist/context/layers/{working-memory-context.d.ts → scratchpad.d.ts}

@@ -1,20 +1,20 @@
 import type { ZodType } from 'zod';
-export type WorkingMemoryContextState = string | Record<string, unknown>;
-export interface WorkingMemoryContextConfig {
+export type ScratchpadState = string | Record<string, unknown>;
+export interface ScratchpadConfig {
     scope?: 'thread' | 'resource';
     schema?: ZodType;
     template?: string;
     readOnly?: boolean;
 }
 /**
- * Creates a mutable working context layer that the model can update via the `working-context/update` tool.
+ * Creates a mutable scratchpad context layer that the model can update via the `scratchpad/update` tool.
  *
  * @public
  * @param config - Optional configuration for scope, Zod schema, template, and read-only mode.
  * @returns A `ContextLayer` providing scratchpad state the model can read and write.
  */
-export declare function workingMemoryContext(config?: WorkingMemoryContextConfig): {
-    id: 'working-context';
+export declare function scratchpad(config?: ScratchpadConfig): {
+    id: 'scratchpad';
     name: string;
     slot: 100;
     scope: "resource" | "thread";
@@ -23,24 +23,24 @@ export declare function workingMemoryContext(config?: WorkingMemoryContextConfig
         max: number;
     };
     provides: {
-        snapshot: import("@noetic-tools/types").LayerDataDecl<WorkingMemoryContextState, WorkingMemoryContextState>;
-        update: import("@noetic-tools/types").LayerFunctionDecl<Record<string, unknown>, void, WorkingMemoryContextState>;
+        snapshot: import("@noetic-tools/types").LayerDataDecl<ScratchpadState, ScratchpadState>;
+        update: import("@noetic-tools/types").LayerFunctionDecl<Record<string, unknown>, void, ScratchpadState>;
     };
     hooks: {
         init({ storage }: import("@noetic-tools/types").InitParams): Promise<{
             state: {};
         } | {
-            state: WorkingMemoryContextState;
+            state: ScratchpadState;
         }>;
-        recall({ state }: import("@noetic-tools/types").RecallParams<WorkingMemoryContextState>): Promise<{
+        recall({ state }: import("@noetic-tools/types").RecallParams<ScratchpadState>): Promise<{
             items: import("@noetic-tools/types").InputMessageItem[];
             tokenCount: number;
         } | null>;
-        store({ newItems, state }: import("@noetic-tools/types").StoreParams<WorkingMemoryContextState>): Promise<{
-            state: WorkingMemoryContextState;
+        store({ newItems, state }: import("@noetic-tools/types").StoreParams<ScratchpadState>): Promise<{
+            state: ScratchpadState;
         } | undefined>;
-        onSpawn({ parentState }: import("@noetic-tools/types").SpawnParams<WorkingMemoryContextState>): Promise<{
-            childState: WorkingMemoryContextState;
+        onSpawn({ parentState }: import("@noetic-tools/types").SpawnParams<ScratchpadState>): Promise<{
+            childState: ScratchpadState;
         } | null>;
     };
 };

package/dist/context/layers/{working-memory-context.js → scratchpad.js}

@@ -1,7 +1,7 @@
 import { createMessage, estimateTokens, Slot } from '@noetic-tools/types';
 import { z } from 'zod';
 import { findFunctionCall } from '../function-call-utils.js';
-import { layerData, layerFn } from '../layer-provides.js';
+import { layerData, layerFunction } from '../layer-provides.js';
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -33,7 +33,7 @@ function deepMerge(target, source, depth = 0) {
     return out;
 }
 /**
- * Validate a MERGED working-context state against the configured schema (a
+ * Validate a MERGED scratchpad state against the configured schema (a
  * pure gate — the original value is returned, transforms are not applied).
  * Validating the merged state (not the raw update) keeps partial updates
  * legal under schemas with required fields. Throws on failure so the update
@@ -45,7 +45,7 @@ function applySchema(schema, merged) {
     }
     const result = schema.safeParse(merged);
     if (!result.success) {
-        throw new Error(`working-context update rejected by schema: ${result.error.message}`);
+        throw new Error(`scratchpad update rejected by schema: ${result.error.message}`);
     }
     return merged;
 }
@@ -66,17 +66,17 @@ function safeMerge(state, args) {
     return merged;
 }
 /**
- * Creates a mutable working context layer that the model can update via the `working-context/update` tool.
+ * Creates a mutable scratchpad context layer that the model can update via the `scratchpad/update` tool.
  *
  * @public
  * @param config - Optional configuration for scope, Zod schema, template, and read-only mode.
  * @returns A `ContextLayer` providing scratchpad state the model can read and write.
  */
-export function workingMemoryContext(config) {
+export function scratchpad(config) {
     const scope = config?.scope ?? 'thread';
     return {
-        id: 'working-context',
-        name: 'Working Memory',
+        id: 'scratchpad',
+        name: 'Scratchpad',
         slot: Slot.WORKING_MEMORY,
         scope,
         budget: {
@@ -87,7 +87,7 @@ export function workingMemoryContext(config) {
             snapshot: layerData({
                 read: (state) => state,
             }),
-            update: layerFn({
+            update: layerFunction({
                 description: 'Update the agent working context with new key-value pairs.',
                 input: z.record(z.string(), z.unknown()),
                 output: z.void(),

package/dist/context/layers/steering.d.ts

@@ -11,6 +11,7 @@ export declare function steering(config: SteeringConfig): {
     name: string;
     slot: 90;
     scope: ContextScope;
+    placement: "live";
     budget: {
         min: number;
         max: number;

package/dist/context/layers/steering.js

@@ -9,7 +9,7 @@ function requireCallModel(params, ruleId) {
         throw new NoeticConfigError({
             code: 'MISSING_CALL_MODEL',
             message: `LLM-evaluated steering rule "${ruleId}" requires a callModel but none is available.`,
-            hint: 'Pass `llm: { provider: "openrouter", apiKey: "..." }` to AgentHarness or set OPENROUTER_API_KEY.',
+            hint: 'Pass `callModelDefaults: { apiKey: "..." }` (defaults to the Noetic platform) to AgentHarness or set NOETIC_API_KEY. For direct OpenRouter, use `callModelDefaults: { provider: "openrouter", apiKey: "..." }` or set OPENROUTER_API_KEY.',
         });
     }
 }
@@ -162,6 +162,11 @@ export function steering(config) {
         name: 'Steering',
         slot: Slot.STEERING,
         scope,
+        // `recall` drains the pending queue as it renders, so its output can never
+        // be replayed from a pin — the drain is already committed, and serving an
+        // older render would lose the feedback for good. Rendering after history
+        // also puts guidance where the model weighs it most.
+        placement: 'live',
         budget: {
             min: 0,
             max: 500,

package/dist/context/layers/{durable-task-state.d.ts → task-state.d.ts}

@@ -1,4 +1,4 @@
-export interface DurableTaskState {
+export interface TaskState {
     checkpoints: Array<{
         timestamp: number;
         depth: number;
@@ -7,7 +7,7 @@ export interface DurableTaskState {
     data: Record<string, unknown>;
 }
 /**
- * How a child's `data` map is merged into the parent's at a spawn/fork return.
+ * How a child's `data` map is merged into the parent's at a spawn/inParallel return.
  *
  * - `'shallow'` — `{ ...parent, ...child }`. Concurrent children that write the
  *   same key clobber each other (last to return wins). Fine for a single child.
@@ -18,15 +18,15 @@ export interface DurableTaskState {
  *
  * @public
  */
-export type DurableTaskDataMerge = 'shallow' | 'namespace';
-/** @public Options for {@link durableTaskState}. */
-export interface DurableTaskStateOptions {
+export type TaskStateDataMerge = 'shallow' | 'namespace';
+/** @public Options for {@link taskState}. */
+export interface TaskStateOptions {
     /**
      * Merge strategy for `data` at a child boundary. Defaults to `'shallow'`.
      * Use `'namespace'` for coordinator/worker fan-out, where several children
      * return concurrently into one parent.
      */
-    mergeData?: DurableTaskDataMerge;
+    mergeData?: TaskStateDataMerge;
 }
 /**
  * Creates a context layer that persists task checkpoints, files, and arbitrary data across iterations.
@@ -36,8 +36,8 @@ export interface DurableTaskStateOptions {
  * (newest 50 kept) and `recall` trims its render to the allocated budget.
  *
  * The layer is writable from the model: `provides` exposes
- * `durable-task-state/recordArtifact` (append a produced/modified file path)
- * and `durable-task-state/setTaskData` (record a structured result under a
+ * `task-state/recordArtifact` (append a produced/modified file path)
+ * and `task-state/setTaskData` (record a structured result under a
  * key). Both survive the spawn boundary — a worker's artifacts merge back into
  * its coordinator via `onReturn`.
  *
@@ -45,8 +45,8 @@ export interface DurableTaskStateOptions {
  * @param opts - Layer options; `mergeData` selects the `data` merge strategy at a child boundary.
  * @returns A `ContextLayer` scoped to the thread with durable task state.
  */
-export declare function durableTaskState(opts?: DurableTaskStateOptions): {
-    id: 'durable-task-state';
+export declare function taskState(opts?: TaskStateOptions): {
+    id: 'task-state';
     name: string;
     slot: number;
     scope: "thread";
@@ -60,28 +60,28 @@ export declare function durableTaskState(opts?: DurableTaskStateOptions): {
     provides: {
         recordArtifact: import("@noetic-tools/types").LayerFunctionDecl<{
             path: string;
-        }, string, DurableTaskState>;
+        }, string, TaskState>;
         setTaskData: import("@noetic-tools/types").LayerFunctionDecl<{
             key: string;
             value: unknown;
-        }, string, DurableTaskState>;
+        }, string, TaskState>;
     };
     hooks: {
         init({ storage }: import("@noetic-tools/types").InitParams): Promise<{
-            state: DurableTaskState;
+            state: TaskState;
         }>;
-        recall({ state, budget }: import("@noetic-tools/types").RecallParams<DurableTaskState>): Promise<{
+        recall({ state, budget }: import("@noetic-tools/types").RecallParams<TaskState>): Promise<{
             items: import("@noetic-tools/types").InputMessageItem[];
             tokenCount: number;
         } | null>;
-        store({ state, ctx }: import("@noetic-tools/types").StoreParams<DurableTaskState>): Promise<{
-            state: DurableTaskState;
+        store({ state, ctx }: import("@noetic-tools/types").StoreParams<TaskState>): Promise<{
+            state: TaskState;
         }>;
-        onSpawn({ parentState }: import("@noetic-tools/types").SpawnParams<DurableTaskState>): Promise<{
-            childState: DurableTaskState;
+        onSpawn({ parentState }: import("@noetic-tools/types").SpawnParams<TaskState>): Promise<{
+            childState: TaskState;
             items: never[];
         }>;
-        onReturn({ childState, parentState, childCtx }: import("@noetic-tools/types").ReturnParams<DurableTaskState>): Promise<{
+        onReturn({ childState, parentState, childCtx }: import("@noetic-tools/types").ReturnParams<TaskState>): Promise<{
             parentState: {
                 checkpoints: {
                     timestamp: number;
@@ -91,7 +91,7 @@ export declare function durableTaskState(opts?: DurableTaskStateOptions): {
                 data: Record<string, unknown>;
             };
         }>;
-        onComplete({ state, outcome, ctx }: import("@noetic-tools/types").CompleteParams<DurableTaskState>): Promise<{
+        onComplete({ state, outcome, ctx }: import("@noetic-tools/types").CompleteParams<TaskState>): Promise<{
             state: {
                 files: string[];
                 data: {

package/dist/context/layers/{durable-task-state.js → task-state.js}

@@ -1,6 +1,6 @@
 import { createMessage, estimateTokens, Slot } from '@noetic-tools/types';
 import { z } from 'zod';
-import { layerFn } from '../layer-provides.js';
+import { layerFunction } from '../layer-provides.js';
 /**
  * Hard cap on retained checkpoints. store() appends one per model call and
  * onReturn concatenates the child's list, so without a cap the thread-scoped
@@ -37,8 +37,8 @@ function mergeChildData({ parent, childState, childExecutionId, mergeData, }) {
  * (newest 50 kept) and `recall` trims its render to the allocated budget.
  *
  * The layer is writable from the model: `provides` exposes
- * `durable-task-state/recordArtifact` (append a produced/modified file path)
- * and `durable-task-state/setTaskData` (record a structured result under a
+ * `task-state/recordArtifact` (append a produced/modified file path)
+ * and `task-state/setTaskData` (record a structured result under a
  * key). Both survive the spawn boundary — a worker's artifacts merge back into
  * its coordinator via `onReturn`.
  *
@@ -46,11 +46,11 @@ function mergeChildData({ parent, childState, childExecutionId, mergeData, }) {
  * @param opts - Layer options; `mergeData` selects the `data` merge strategy at a child boundary.
  * @returns A `ContextLayer` scoped to the thread with durable task state.
  */
-export function durableTaskState(opts = {}) {
+export function taskState(opts = {}) {
     const mergeData = opts.mergeData ?? 'shallow';
     return {
-        id: 'durable-task-state',
-        name: 'Durable Task State',
+        id: 'task-state',
+        name: 'Task State',
         slot: Slot.WORKING_MEMORY + 10, // 110
         // 'thread' (not 'execution'): the layer's purpose is to persist task state
         // ACROSS executions/iterations within a thread. 'execution' scope rotates
@@ -65,7 +65,7 @@ export function durableTaskState(opts = {}) {
             store: 30_000,
         },
         provides: {
-            recordArtifact: layerFn({
+            recordArtifact: layerFunction({
                 description: 'Record a file this task produced or modified. Recorded paths survive the task boundary and merge back into the parent task.',
                 input: z.object({
                     path: z.string().min(1),
@@ -90,7 +90,7 @@ export function durableTaskState(opts = {}) {
                     };
                 },
             }),
-            setTaskData: layerFn({
+            setTaskData: layerFunction({
                 description: 'Record a structured result for this task under a key (e.g. a PR url, a verdict, a summary). Values survive the task boundary and merge back into the parent task.',
                 input: z.object({
                     key: z.string().min(1),
@@ -136,7 +136,7 @@ export function durableTaskState(opts = {}) {
                 }
                 let view = state;
                 let text = renderTaskState(view);
-                // `budget > 0` is the fail-open convention (see staticContent): a zero
+                // `budget > 0` is the fail-open convention (see instructions): a zero
                 // allocation must not delete the task state from the view.
                 if (budget > 0) {
                     // Halve the OLDEST checkpoints while the render exceeds the budget —

package/dist/context/layers/{temporal-context.d.ts → temporal.d.ts}

@@ -23,7 +23,7 @@ export interface TemporalSearchResult {
 }
 /**
  * Extracts timestamped facts from a batch of conversation text. Host-injected so
- * the layer stays LLM-agnostic and tree-shakable (mirrors `observationalContext`'s
+ * the layer stays LLM-agnostic and tree-shakable (mirrors `observations`'s
  * `observer`). When omitted, the layer only buffers — it never fabricates facts.
  * @public
  */
@@ -42,10 +42,10 @@ export type FactSearcher = (input: {
     now: string;
 }) => Promise<TemporalSearchResult>;
 /**
- * Configuration for {@link temporalContext}.
+ * Configuration for {@link temporal}.
  * @public
  */
-export interface TemporalContextConfig {
+export interface TemporalConfig {
     /** Returns "now" for date grounding/extraction. Defaults to the system clock. */
     now?: () => Date;
     /** Context scope. Defaults to `'resource'` (long-term, cross-session). */
@@ -78,7 +78,7 @@ interface TemporalState {
  * returns matching facts and, when applicable, a resolved (possibly fuzzy) date.
  *
  * The layer is LLM-agnostic: the host injects `extract` and `search` callbacks
- * (mirrors `observationalContext`'s `observer`), keeping `context/` tree-shakable.
+ * (mirrors `observations`'s `observer`), keeping `context/` tree-shakable.
  * Without them, the layer still buffers text and the search tool returns the raw
  * ledger — it never fabricates facts. A `<current_datetime>` grounding block is
  * injected on recall by default to anchor relative-time reasoning.
@@ -87,5 +87,5 @@ interface TemporalState {
  * @param config - Clock, scope, injected LLM callbacks, and tuning knobs.
  * @returns A `ContextLayer` with a fact-ledger store + `searchMemory` tool.
  */
-export declare function temporalContext(config?: TemporalContextConfig): ContextLayer<TemporalState>;
+export declare function temporal(config?: TemporalConfig): ContextLayer<TemporalState>;
 export {};

package/dist/context/layers/{temporal-context.js → temporal.js}

@@ -1,6 +1,6 @@
 import { collectInputText, collectOutputText, createMessage, estimateTokens, Slot, } from '@noetic-tools/types';
 import { z } from 'zod';
-import { layerFn } from '../layer-provides.js';
+import { layerFunction } from '../layer-provides.js';
 function emptyState() {
     return {
         facts: {},
@@ -188,7 +188,7 @@ async function accumulate(s, texts, cfg) {
  * returns matching facts and, when applicable, a resolved (possibly fuzzy) date.
  *
  * The layer is LLM-agnostic: the host injects `extract` and `search` callbacks
- * (mirrors `observationalContext`'s `observer`), keeping `context/` tree-shakable.
+ * (mirrors `observations`'s `observer`), keeping `context/` tree-shakable.
  * Without them, the layer still buffers text and the search tool returns the raw
  * ledger — it never fabricates facts. A `<current_datetime>` grounding block is
  * injected on recall by default to anchor relative-time reasoning.
@@ -197,7 +197,7 @@ async function accumulate(s, texts, cfg) {
  * @param config - Clock, scope, injected LLM callbacks, and tuning knobs.
  * @returns A `ContextLayer` with a fact-ledger store + `searchMemory` tool.
  */
-export function temporalContext(config) {
+export function temporal(config) {
     const now = config?.now ?? (() => new Date());
     const threshold = config?.bufferThreshold ?? DEFAULT_BUFFER_THRESHOLD_TOKENS;
     const maxFacts = config?.maxFacts ?? DEFAULT_MAX_FACTS;
@@ -207,10 +207,16 @@ export function temporalContext(config) {
     const search = config?.search;
     return {
         id: 'temporal',
-        name: 'Temporal Context',
+        name: 'Temporal',
         // Grounding sits near the top of the window, before reasoning content.
         slot: Slot.REMINDER,
         scope: config?.scope ?? 'resource',
+        // The `<current_datetime>` block changes every turn by construction, so
+        // anchoring it would re-bill the whole window each time. Churn telemetry
+        // would reach the same verdict — this just skips the learning cost. With
+        // grounding off, only the slow-moving fact ledger remains, which is worth
+        // anchoring, so leave that to `'auto'`.
+        placement: groundDateTime ? 'live' : 'auto',
         budget: {
             min: 0,
             max: injectLedger ? 800 : 200,
@@ -222,7 +228,7 @@ export function temporalContext(config) {
             onItemAppend: 60_000,
         },
         provides: {
-            searchMemory: layerFn({
+            searchMemory: layerFunction({
                 description: 'Search remembered facts about the user by topic or fact, and resolve relative time. Returns matching facts and, when the query implies a time, a resolved date (which may be approximate).',
                 input: z.object({
                     query: z.string(),

package/dist/context/layers/{tool-context-layer.d.ts → tool-calls.d.ts}

@@ -1,5 +1,5 @@
 import type { ContextLayer, Tool } from '@noetic-tools/types';
-interface ToolContextLayerOpts {
+interface ToolCallsOptions {
     slot?: number;
 }
 /**
@@ -11,5 +11,5 @@ interface ToolContextLayerOpts {
  * @param opts - Optional slot override for the generated layers.
  * @returns An array of `ContextLayer` instances, one per unique tool context id.
  */
-export declare function toolContextLayer(tools: ReadonlyArray<Tool>, opts?: ToolContextLayerOpts): ContextLayer[];
+export declare function toolCalls(tools: ReadonlyArray<Tool>, opts?: ToolCallsOptions): ContextLayer[];
 export {};

package/dist/context/layers/{tool-context-layer.js → tool-calls.js}

@@ -9,7 +9,7 @@ const EXECUTION_SCOPE = 'execution';
  * @param opts - Optional slot override for the generated layers.
  * @returns An array of `ContextLayer` instances, one per unique tool context id.
  */
-export function toolContextLayer(tools, opts) {
+export function toolCalls(tools, opts) {
     const seen = new Map();
     for (const t of tools) {
         if (!t.context) {

package/dist/context/projector.d.ts

@@ -1,19 +1,38 @@
 import type { Item, ProjectionPolicy } from '@noetic-tools/types';
 interface AssembleViewParams {
     systemPromptItems: Item[];
+    /** Anchor band — layer output rendered before history, where a prompt cache can hold it. */
     layerOutputItems: Item[];
     historyItems: Item[];
+    /** Live band — layer output rendered after history, slot-ascending. */
+    liveLayerItems?: Item[];
+    /** Supersedes for anchored layers whose pinned output went stale. */
+    deltaItems?: Item[];
+    /** Items that must land last, after everything else. Never dropped. */
+    tailItems?: Item[];
     policy?: ProjectionPolicy;
 }
 /**
- * Assemble the model's context window from system prompt items, context-layer
- * recall output (slot-ascending), and conversation history.
+ * Assemble the model's context window in bands:
  *
- * Without a `policy` the inputs are concatenated as-is (optionally sliding the
- * history window by `windowSize`). With a `policy` the assembled view is held to
- * a hard token budget: system items are always kept; layer output is kept
- * low-slot-first (highest-slot dropped when tight); history takes the remainder,
- * keeping the most recent turns.
+ * ```
+ * system | anchor layers | history | live layers | supersedes | tail
+ * ```
+ *
+ * The split exists for the prompt cache, which matches on a prefix. Stable
+ * layer output sits ahead of history where it can be cached; volatile output
+ * sits after it, where re-rendering costs almost nothing. Both bands arrive
+ * slot-ascending.
+ *
+ * Without a `policy` the bands are concatenated as-is (optionally sliding the
+ * history window by `windowSize`). With a `policy` the view is held to a hard
+ * token budget, claimed in this order: system items, then anchor output, then
+ * live output, then supersedes, then the tail — with history taking whatever
+ * remains and keeping the most recent turns.
+ *
+ * Supersedes are claimed ahead of history, and all together or not at all: a
+ * dropped supersede would leave the model reading a pinned block the runtime
+ * knows is stale. The caller re-anchors instead — see `prepareBandedView`.
  */
-export declare function assembleView({ systemPromptItems, layerOutputItems, historyItems, policy, }: AssembleViewParams): Item[];
+export declare function assembleView({ systemPromptItems, layerOutputItems, historyItems, liveLayerItems, deltaItems, tailItems, policy, }: AssembleViewParams): Item[];
 export {};

package/dist/context/projector.js

@@ -57,33 +57,62 @@ function keepRecentWithinBudget(items, budget, windowSize) {
 //#endregion
 //#region Public API
 /**
- * Assemble the model's context window from system prompt items, context-layer
- * recall output (slot-ascending), and conversation history.
+ * Assemble the model's context window in bands:
  *
- * Without a `policy` the inputs are concatenated as-is (optionally sliding the
- * history window by `windowSize`). With a `policy` the assembled view is held to
- * a hard token budget: system items are always kept; layer output is kept
- * low-slot-first (highest-slot dropped when tight); history takes the remainder,
- * keeping the most recent turns.
+ * ```
+ * system | anchor layers | history | live layers | supersedes | tail
+ * ```
+ *
+ * The split exists for the prompt cache, which matches on a prefix. Stable
+ * layer output sits ahead of history where it can be cached; volatile output
+ * sits after it, where re-rendering costs almost nothing. Both bands arrive
+ * slot-ascending.
+ *
+ * Without a `policy` the bands are concatenated as-is (optionally sliding the
+ * history window by `windowSize`). With a `policy` the view is held to a hard
+ * token budget, claimed in this order: system items, then anchor output, then
+ * live output, then supersedes, then the tail — with history taking whatever
+ * remains and keeping the most recent turns.
+ *
+ * Supersedes are claimed ahead of history, and all together or not at all: a
+ * dropped supersede would leave the model reading a pinned block the runtime
+ * knows is stale. The caller re-anchors instead — see `prepareBandedView`.
  */
-export function assembleView({ systemPromptItems, layerOutputItems, historyItems, policy, }) {
+export function assembleView({ systemPromptItems, layerOutputItems, historyItems, liveLayerItems = [], deltaItems = [], tailItems = [], policy, }) {
     if (!policy) {
         return [
             ...systemPromptItems,
             ...layerOutputItems,
             ...historyItems,
+            ...liveLayerItems,
+            ...deltaItems,
+            ...tailItems,
         ];
     }
     const budget = Math.max(0, policy.tokenBudget - policy.responseReserve);
     // System items are never dropped — they anchor the conversation.
-    const afterSystem = Math.max(0, budget - totalTokens(systemPromptItems));
-    const keptLayers = keepFrontWithinBudget(layerOutputItems, afterSystem);
-    const afterLayers = Math.max(0, afterSystem - totalTokens(keptLayers));
-    const keptHistory = keepRecentWithinBudget(historyItems, afterLayers, policy.windowSize);
+    let left = Math.max(0, budget - totalTokens(systemPromptItems));
+    const keptAnchor = keepFrontWithinBudget(layerOutputItems, left);
+    left = Math.max(0, left - totalTokens(keptAnchor));
+    const keptLive = keepFrontWithinBudget(liveLayerItems, left);
+    left = Math.max(0, left - totalTokens(keptLive));
+    // The tail carries steering guidance, which must reach the model whatever the
+    // budget says — it is the correction the retry exists to deliver.
+    left = Math.max(0, left - totalTokens(tailItems));
+    // Supersedes are never dropped either. Each one corrects a pinned block that
+    // is already in the view, so dropping one leaves the model reading content
+    // the runtime knows is stale — silent corruption, and far worse than losing
+    // a turn of history. History absorbs the cost; `deltaBudgetFraction` keeps
+    // the supersedes from growing large enough for that to hurt.
+    left = Math.max(0, left - totalTokens(deltaItems));
+    const keptHistory = keepRecentWithinBudget(historyItems, left, policy.windowSize);
     return [
         ...systemPromptItems,
-        ...keptLayers,
+        ...keptAnchor,
         ...keptHistory,
+        ...keptLive,
+        ...deltaItems,
+        ...tailItems,
     ];
 }
 //#endregion

package/dist/context/strip-unresolved.d.ts

@@ -6,7 +6,7 @@
  *
  * Mirrors Claude Code's `filterUnresolvedToolUses`. Used by the CLI's
  * session-resume path to drop dangling pairs left by a crash, and by the
- * `historyWindow` context layer to clean orphans at the slice boundary.
+ * `history` context layer to clean orphans at the slice boundary.
  */
 import type { Item } from '@noetic-tools/types';
 /** @public */

package/dist/context/strip-unresolved.js

@@ -6,7 +6,7 @@
  *
  * Mirrors Claude Code's `filterUnresolvedToolUses`. Used by the CLI's
  * session-resume path to drop dangling pairs left by a crash, and by the
- * `historyWindow` context layer to clean orphans at the slice boundary.
+ * `history` context layer to clean orphans at the slice boundary.
  */
 /** @public */
 export function stripUnresolvedToolCalls(items) {

package/dist/index.d.ts

@@ -6,24 +6,24 @@
 export type { ContextScope, ExecutionContext, ExecutionOutcome, LayerCallModelRequest, } from '@noetic-tools/types';
 export * from '@noetic-tools/types/contract';
 export * from './context/budget.js';
+export * from './context/cache-anchoring.js';
 export * from './context/exec-context-factory.js';
 export * from './context/function-call-utils.js';
 export * from './context/layer-api.js';
 export * from './context/layer-lifecycle.js';
 export * from './context/layer-provides.js';
 export * from './context/layer-usage.js';
-export * from './context/layers/durable-task-state.js';
-export * from './context/layers/file-reference.js';
-export * from './context/layers/history-window.js';
-export * from './context/layers/observational-context.js';
-export * from './context/layers/plan-context.js';
-export * from './context/layers/static-content.js';
+export * from './context/layers/filesystem.js';
+export * from './context/layers/history.js';
+export * from './context/layers/instructions.js';
+export * from './context/layers/observations.js';
+export * from './context/layers/plan.js';
+export * from './context/layers/scratchpad.js';
 export * from './context/layers/steering.js';
-export * from './context/layers/temporal-context.js';
-export * from './context/layers/tool-context-layer.js';
-export * from './context/layers/working-memory-context.js';
+export * from './context/layers/task-state.js';
+export * from './context/layers/temporal.js';
+export * from './context/layers/tool-calls.js';
 export * from './context/projector.js';
 export * from './context/scope.js';
 export * from './context/storage-batch.js';
 export * from './context/strip-unresolved.js';
-export * from './deprecated.js';

package/dist/index.js

@@ -8,24 +8,24 @@
 // @noetic-tools/context remains the one-stop import for context-layer authoring.
 export * from '@noetic-tools/types/contract';
 export * from './context/budget.js';
+export * from './context/cache-anchoring.js';
 export * from './context/exec-context-factory.js';
 export * from './context/function-call-utils.js';
 export * from './context/layer-api.js';
 export * from './context/layer-lifecycle.js';
 export * from './context/layer-provides.js';
 export * from './context/layer-usage.js';
-export * from './context/layers/durable-task-state.js';
-export * from './context/layers/file-reference.js';
-export * from './context/layers/history-window.js';
-export * from './context/layers/observational-context.js';
-export * from './context/layers/plan-context.js';
-export * from './context/layers/static-content.js';
+export * from './context/layers/filesystem.js';
+export * from './context/layers/history.js';
+export * from './context/layers/instructions.js';
+export * from './context/layers/observations.js';
+export * from './context/layers/plan.js';
+export * from './context/layers/scratchpad.js';
 export * from './context/layers/steering.js';
-export * from './context/layers/temporal-context.js';
-export * from './context/layers/tool-context-layer.js';
-export * from './context/layers/working-memory-context.js';
+export * from './context/layers/task-state.js';
+export * from './context/layers/temporal.js';
+export * from './context/layers/tool-calls.js';
 export * from './context/projector.js';
 export * from './context/scope.js';
 export * from './context/storage-batch.js';
 export * from './context/strip-unresolved.js';
-export * from './deprecated.js';