@noetic-tools/core 5.2.0 → 5.4.0

package/dist/harness/agent-harness.d.ts

@@ -2,32 +2,19 @@ import { ItemSchemaRegistry } from '@noetic-tools/types';
 import type { LayerStateStore, RecallCache } from './deps/context.js';
 import type { DetachedSpawnOverrides } from './deps/interpreter.js';
 import type { CheckpointStore, EventBroadcaster, RestoreCheckpointOptions, StepLedgerRetention, StepLedgerStore } from './deps/runtime.js';
-import type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, ContextData, ContextLayer, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, ProjectionPolicy, RecallLayerOutput, SessionScope, ShellAdapter, Span, SteeringDecision, Step, StorageAdapter, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, ZodType } from './deps/types.js';
+import type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, ContextCacheConfig, ContextCacheStore, ContextData, ContextLayer, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaConfig, LLMResponse, LlmProviderConfig, ProjectionPolicy, RecallLayerOutput, SessionScope, SessionUsage, ShellAdapter, Span, SteeringDecision, Step, StorageAdapter, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, ZodType } from './deps/types.js';
 export { createStreamIdleWatchdog } from './model-call.js';
-interface AgentHarnessOpts<TParams extends Record<string, unknown> = Record<string, unknown>> {
-    name: string;
-    initialStep?: Step<ContextData, string, string>;
-    /** Default context layers applied to every context created via `createContext()` / `execute()`. */
-    context?: ContextLayer[];
-    /** @deprecated Renamed to `context`. */
-    memory?: ContextLayer[];
-    storage?: StorageAdapter;
-    hooks?: AgentHooks;
+/**
+ * Storage-scoped environment configuration for `AgentHarness`.
+ *
+ * @public
+ */
+export interface StorageEnvironmentConfig {
     /**
-     * Harness-wide tool pool. Merged (identity-deduplicated) with tools
-     * collected from `initialStep` to form every context's `unifiedTools`.
-     * Use this when the workflow step tree is static and tools are supplied
-     * per harness instance rather than baked into individual `step.llm` calls.
+     * Key-value storage adapter backing context-layer persistence and the
+     * step-completion ledger. Defaults to an in-memory adapter.
      */
-    tools?: Tool[];
-    params: TParams;
-    paramsSchema?: ZodType<TParams>;
-    /** Filesystem adapter. Defaults to local node:fs when not provided. */
-    fs?: FsAdapter;
-    /** Shell adapter. Defaults to local sh when not provided. */
-    shell?: ShellAdapter;
-    /** Subprocess adapter. Defaults to an in-memory, same-process adapter. */
-    subprocess?: SubprocessAdapter;
+    adapter?: StorageAdapter;
     /**
      * Checkpoint store used by `harness.checkpoint(ctx)` / `harness.restore()`.
      * When absent, checkpoint/restore are no-ops — a zero-config harness keeps
@@ -35,6 +22,8 @@ interface AgentHarnessOpts<TParams extends Record<string, unknown> = Record<stri
      * to enable durable execution.
      */
     checkpointStore?: CheckpointStore;
+    /** Layer-state store override. Defaults to an in-memory store. */
+    layerStateStore?: LayerStateStore;
     /**
      * Bounds on the step-completion ledger that backs step-level resume. Only meaningful
      * alongside a `checkpointStore`. Defaults to `DEFAULT_STEP_LEDGER_RETENTION` — 128 KiB
@@ -43,25 +32,54 @@ interface AgentHarnessOpts<TParams extends Record<string, unknown> = Record<stri
      * never correctness.
      */
     stepLedgerRetention?: StepLedgerRetention;
-    llm?: LlmProviderConfig;
-    /** Harness-wide item schema extensions. */
-    itemSchemas?: ItemSchemaExtensions;
-    /** Whether unknown extension item types must match a registered schema. Defaults to true. */
-    strictItemSchemas?: boolean;
+}
+/**
+ * Execution-environment configuration for `AgentHarness`: the storage,
+ * filesystem, shell, and subprocess surfaces the agent runs against.
+ *
+ * @public
+ */
+export interface AgentEnvironmentConfig {
+    /** Storage configuration: adapter, durability stores, ledger retention. */
+    storage?: StorageEnvironmentConfig;
+    /** Filesystem adapter. Defaults to an in-memory adapter. */
+    fs?: FsAdapter;
+    /** Shell adapter. Defaults to an in-memory adapter. */
+    shell?: ShellAdapter;
+    /** Subprocess adapter. Defaults to an in-memory, same-process adapter. */
+    subprocess?: SubprocessAdapter;
+}
+interface AgentHarnessOpts<TParams extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    /** Root step tree executed for every turn submitted via `execute()`. */
+    agentGraph?: Step<ContextData, string, string>;
+    /** Default context layers applied to every context created via `createContext()` / `execute()`. */
+    contextLayers?: ContextLayer[];
+    hooks?: AgentHooks;
+    /**
+     * Harness-wide tool pool. Merged (identity-deduplicated) with tools
+     * collected from `agentGraph` to form every context's `unifiedTools`.
+     * Use this when the workflow step tree is static and tools are supplied
+     * per harness instance rather than baked into individual `step.callModel` calls.
+     */
+    tools?: Tool[];
+    params: TParams;
+    paramsSchema?: ZodType<TParams>;
+    /** Execution environment: storage, filesystem, shell, subprocess. */
+    environment?: AgentEnvironmentConfig;
+    /** Default provider configuration for model calls made through this harness. */
+    callModelDefaults?: LlmProviderConfig;
+    /** Harness-wide item schema extensions and validation strictness. */
+    itemSchemas?: ItemSchemaConfig;
     /** Default projection policy for all LLM steps. Individual steps override via `step.projection`. */
     projection?: ProjectionPolicy;
     /** When true, every layer is recalled atomically regardless of its `recallMode`. */
     forceAtomicRecall?: boolean;
+    /** Tuning for prompt-cache anchoring. See `ContextCacheConfig` for the defaults. */
+    contextCache?: ContextCacheConfig;
     traceExporter?: TraceExporter;
-    layerStateStore?: LayerStateStore;
     /** Default delivery mode for messages that don't specify one. Defaults to `next-turn`. */
     defaultDeliveryMode?: DeliveryMode;
-    /**
-     * Abort the in-flight model call if the provider stream emits no events for this
-     * many milliseconds. Defaults to `DEFAULT_STREAM_IDLE_TIMEOUT_MS` (120s).
-     * Pass `0` or a negative number to disable the watchdog.
-     */
-    streamIdleTimeoutMs?: number;
     /**
      * Initial working directory for the harness. Used as the seed value for the
      * shared `cwdState.cwd` on every Context this harness creates, including
@@ -127,7 +145,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * @internal
      */
     readonly stepLedgerRetention: Required<StepLedgerRetention>;
-    private readonly initialStep?;
+    private readonly agentGraph?;
     /** Harness-wide tool pool merged into every context's `unifiedTools`. */
     private readonly harnessTools;
     /** @internal Context layers configured for this harness. Exposed non-private
@@ -140,7 +158,6 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     private readonly rootRunDepth;
     private readonly callModelOverride?;
     private readonly defaultDeliveryMode;
-    private readonly streamIdleTimeoutMs;
     private readonly sessions;
     /**
      * @internal Cross-step harness sessions keyed by `step.session.reuse`, kept
@@ -152,6 +169,8 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     readonly layerStateStore: LayerStateStore;
     /** Per-harness memoization cache for `recallMode: 'eventual'` layers. */
     readonly recallCache: RecallCache;
+    /** Per-harness pinned anchor output and epoch bookkeeping, keyed by cache lineage. */
+    readonly contextCache: ContextCacheStore;
     /**
      * Execution ids whose layer `init` hooks have already run, so repeated/nested
      * `run()` calls and the session turn path never re-init (which would clobber
@@ -189,6 +208,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     }): Promise<void>;
     getStatus(scope?: SessionScope): HarnessStatus;
     getQueueSize(scope?: SessionScope): number;
+    getUsage(scope?: SessionScope): SessionUsage;
     seedSessionHistory(threadId: string, items: ReadonlyArray<Item>): void;
     private getOrCreateSession;
     private requireSession;
@@ -221,9 +241,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
         state?: unknown;
         threadId?: string;
         resourceId?: string;
-        context?: ContextLayer[];
-        /** @deprecated Renamed to `context`. */
-        memory?: ContextLayer[];
+        contextLayers?: ContextLayer[];
         /**
          * Initial cwd for the new context. When set, takes precedence over both
          * the parent snapshot and the harness root cwd — used by worktree

package/dist/harness/agent-harness.js

@@ -2,13 +2,12 @@ import { frameworkCast, ItemSchemaRegistry, NoeticConfigError } from '@noetic-to
 import { SpanImpl } from '../observability/span-impl.js';
 import { NoopExporter } from '../observability/trace-exporter.js';
 import { createInMemoryFsAdapter, createInMemoryShellAdapter, createInMemorySubprocessAdapter, OpenRouter, } from './deps/adapters.js';
-import { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from './deps/context.js';
-import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, } from './deps/interpreter.js';
+import { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createContextCacheStore, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from './deps/context.js';
+import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, prepareBandedView, } from './deps/interpreter.js';
 import { buildItemStream, ChannelStore, ContextImpl, captureCheckpoint, clearCheckpoint, collectContextTree, createInMemoryStorage, createStepLedgerStore, filterReasoningStream, filterTextStream, resolveStepLedgerRetention, restoreFromCheckpoint, SessionRunner, StepLedger, snapshotCwdState, } from './deps/runtime.js';
 import { SteeringAction } from './deps/types.js';
 import { AgentHarnessModelCaller } from './model-call.js';
 export { createStreamIdleWatchdog } from './model-call.js';
-import { resolveContextOption } from '../builders/context-option.js';
 import { buildItemSchemaRegistry } from './model-schema.js';
 //#endregion
 const DEFAULT_THREAD_ID = '__default__';
@@ -77,7 +76,43 @@ export function resolveLlmClient(config, env) {
         cache: config?.cache ?? false,
     };
 }
-function createClient(config) {
+/**
+ * Ask the provider to cache the prompt prefix.
+ *
+ * Anthropic caching is opt-in — without a breakpoint it caches nothing however
+ * stable the prefix is, measured against live models. OpenRouter accepts a
+ * `cache_control` directive on the request and places the breakpoints itself;
+ * providers that cache on their own (OpenAI, Gemini) ignore it.
+ *
+ * It has to be injected here rather than passed with the other request fields:
+ * the SDK validates the request against a generated schema that drops keys it
+ * does not know, and `cache_control` is one of them.
+ */
+async function addCacheBreakpoint(request) {
+    const body = await request.clone().text();
+    if (!body) {
+        return request;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        return request;
+    }
+    if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+        return request;
+    }
+    return new Request(request, {
+        body: JSON.stringify({
+            ...payload,
+            cache_control: {
+                type: 'ephemeral',
+            },
+        }),
+    });
+}
+function createClient(config, contextCache) {
     const resolved = resolveLlmClient(config, readLlmEnv());
     if (!resolved) {
         return undefined;
@@ -88,20 +123,25 @@ function createClient(config) {
     if (resolved.serverURL) {
         options.serverURL = resolved.serverURL;
     }
-    if (resolved.cache) {
-        // Inject `X-OpenRouter-Cache: true` on every request so the upstream serves
-        // identical model calls from cache without re-billing (deterministic re-runs).
-        return new OpenRouter({
-            ...options,
-            hooks: {
-                beforeRequest: (_ctx, request) => {
+    // A cache write costs more than a plain read, so the breakpoint only pays off
+    // when something is holding the prefix still — which is what anchoring does.
+    const wantsBreakpoint = contextCache?.enabled !== false;
+    if (!resolved.cache && !wantsBreakpoint) {
+        return new OpenRouter(options);
+    }
+    return new OpenRouter({
+        ...options,
+        hooks: {
+            beforeRequest: async (_ctx, request) => {
+                if (resolved.cache) {
+                    // Serve identical model calls from OpenRouter's own response cache
+                    // without re-billing (deterministic re-runs).
                     request.headers.set('X-OpenRouter-Cache', 'true');
-                    return request;
-                },
+                }
+                return wantsBreakpoint ? addCacheBreakpoint(request) : request;
             },
-        });
-    }
-    return new OpenRouter(options);
+        },
+    });
 }
 //#region AgentHarness
 /**
@@ -137,7 +177,7 @@ export class AgentHarness {
      * @internal
      */
     stepLedgerRetention;
-    initialStep;
+    agentGraph;
     /** Harness-wide tool pool merged into every context's `unifiedTools`. */
     harnessTools;
     /** @internal Context layers configured for this harness. Exposed non-private
@@ -150,7 +190,6 @@ export class AgentHarness {
     rootRunDepth = new Map();
     callModelOverride;
     defaultDeliveryMode;
-    streamIdleTimeoutMs;
     sessions = new Map();
     /**
      * @internal Cross-step harness sessions keyed by `step.session.reuse`, kept
@@ -162,6 +201,8 @@ export class AgentHarness {
     layerStateStore;
     /** Per-harness memoization cache for `recallMode: 'eventual'` layers. */
     recallCache;
+    /** Per-harness pinned anchor output and epoch bookkeeping, keyed by cache lineage. */
+    contextCache;
     /**
      * Execution ids whose layer `init` hooks have already run, so repeated/nested
      * `run()` calls and the session turn path never re-init (which would clobber
@@ -182,43 +223,47 @@ export class AgentHarness {
     itemSchemas;
     constructor(opts) {
         const validatedParams = opts.paramsSchema ? opts.paramsSchema.parse(opts.params) : opts.params;
+        const environment = opts.environment;
+        const storageEnv = environment?.storage;
         this.config = {
             name: opts.name,
-            storage: opts.storage ?? createInMemoryStorage(),
+            storage: storageEnv?.adapter ?? createInMemoryStorage(),
             hooks: opts.hooks,
             params: validatedParams,
             itemSchemas: opts.itemSchemas,
-            strictItemSchemas: opts.strictItemSchemas ?? true,
             projection: opts.projection,
             forceAtomicRecall: opts.forceAtomicRecall,
+            contextCache: opts.contextCache,
         };
-        this.fs = opts.fs ?? createInMemoryFsAdapter();
-        this.shell = opts.shell ?? createInMemoryShellAdapter();
-        this.subprocess = opts.subprocess ?? createInMemorySubprocessAdapter();
-        this.checkpointStore = opts.checkpointStore;
-        this.stepLedgerStore = opts.checkpointStore
+        this.fs = environment?.fs ?? createInMemoryFsAdapter();
+        this.shell = environment?.shell ?? createInMemoryShellAdapter();
+        this.subprocess = environment?.subprocess ?? createInMemorySubprocessAdapter();
+        this.checkpointStore = storageEnv?.checkpointStore;
+        this.stepLedgerStore = storageEnv?.checkpointStore
             ? createStepLedgerStore({
                 storage: this.config.storage ?? createInMemoryStorage(),
             })
             : undefined;
-        this.stepLedgerRetention = resolveStepLedgerRetention(opts.stepLedgerRetention);
-        this.initialStep = opts.initialStep;
+        this.stepLedgerRetention = resolveStepLedgerRetention(storageEnv?.stepLedgerRetention);
+        this.agentGraph = opts.agentGraph;
         this.harnessTools = opts.tools ?? [];
-        this._contextLayers = resolveContextOption(opts);
+        this._contextLayers = opts.contextLayers;
         this.callModelOverride = opts._testCallModel;
-        this.client = opts._testCallModel ? undefined : createClient(opts.llm);
+        this.client = opts._testCallModel
+            ? undefined
+            : createClient(opts.callModelDefaults, opts.contextCache);
         this.channelStore = new ChannelStore();
         this.traceExporter = opts.traceExporter ?? new NoopExporter();
         this.layerStateStore =
-            opts.layerStateStore ??
+            storageEnv?.layerStateStore ??
                 createLayerStateStore((layerId, hook, error) => {
                     console.warn(`[noetic] context layer '${layerId}' ${hook} error:`, error);
                 });
         this.recallCache = createRecallCache();
+        this.contextCache = createContextCacheStore();
         this.defaultDeliveryMode = opts.defaultDeliveryMode ?? 'next-turn';
-        this.streamIdleTimeoutMs = opts.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
-        this.itemSchemas = new ItemSchemaRegistry(opts.itemSchemas, {
-            strictUnknownExtensions: opts.strictItemSchemas ?? true,
+        this.itemSchemas = new ItemSchemaRegistry(opts.itemSchemas?.schemas, {
+            strictUnknownExtensions: opts.itemSchemas?.strict ?? true,
         });
         this.rootCwdState = {
             cwd: opts.initialCwd ?? '/',
@@ -239,11 +284,11 @@ export class AgentHarness {
     }
     //#region Session Accessors
     execute(input, options) {
-        if (!this.initialStep) {
+        if (!this.agentGraph) {
             return Promise.reject(new NoeticConfigError({
                 code: 'NO_STEP_CONFIGURED',
-                message: 'No initialStep configured on this harness.',
-                hint: 'Pass `initialStep` in constructor options, or use run() directly.',
+                message: 'No agentGraph configured on this harness.',
+                hint: 'Pass `agentGraph` in constructor options, or use run() directly.',
             }));
         }
         const threadId = options?.threadId ?? DEFAULT_THREAD_ID;
@@ -308,6 +353,17 @@ export class AgentHarness {
         const session = this.sessions.get(threadId);
         return session ? session.runner.queue.size : 0;
     }
+    getUsage(scope) {
+        const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
+        const session = this.sessions.get(threadId);
+        if (!session) {
+            return {
+                inputTokens: 0,
+                outputTokens: 0,
+            };
+        }
+        return session.runner.getUsage();
+    }
     seedSessionHistory(threadId, items) {
         const session = this.getOrCreateSession(threadId);
         session.accumulatedItems = [
@@ -340,15 +396,15 @@ export class AgentHarness {
                         threadId,
                         resourceId: perTurnOptions.resourceId,
                         state: perTurnOptions.state,
-                        context: resolveContextOption(perTurnOptions),
+                        contextLayers: perTurnOptions.contextLayers,
                         _broadcaster: session.runner.broadcaster,
                     });
                     const ext = frameworkCast(ctx);
                     ext._sessionQueue = session.runner.queue;
                     ext._sessionBetweenRounds = true;
                     ext._sessionRunnerAgentName = this.config.name;
-                    if (this.initialStep || this.harnessTools.length > 0) {
-                        const stepTools = this.initialStep ? collectAllTools(this.initialStep) : [];
+                    if (this.agentGraph || this.harnessTools.length > 0) {
+                        const stepTools = this.agentGraph ? collectAllTools(this.agentGraph) : [];
                         this.setUnifiedTools(ctx, [
                             ...stepTools,
                             ...this.harnessTools,
@@ -357,11 +413,11 @@ export class AgentHarness {
                     return ctx;
                 },
                 runTurn: async (ctx, _turn, signal) => {
-                    if (!this.initialStep) {
+                    if (!this.agentGraph) {
                         throw new NoeticConfigError({
                             code: 'NO_STEP_CONFIGURED',
-                            message: 'No initialStep configured on this harness.',
-                            hint: 'Pass `initialStep` in constructor options.',
+                            message: 'No agentGraph configured on this harness.',
+                            hint: 'Pass `agentGraph` in constructor options.',
                         });
                     }
                     // Wire signal-abort to context-abort so the interpreter bails cleanly.
@@ -375,7 +431,7 @@ export class AgentHarness {
                             once: true,
                         });
                     }
-                    const result = await this.initAndRun(this.initialStep, '', ctx);
+                    const result = await this.initAndRun(this.agentGraph, '', ctx);
                     // Snapshot final items into session history for the next turn.
                     session.accumulatedItems = [
                         ...ctx.itemLog.items,
@@ -405,7 +461,7 @@ export class AgentHarness {
             itemSchemas: this.itemSchemas,
             client: this.client,
             callModelOverride: this.callModelOverride,
-            streamIdleTimeoutMs: this.streamIdleTimeoutMs,
+            streamIdleTimeoutMs: DEFAULT_STREAM_IDLE_TIMEOUT_MS,
             harness: this,
             traceExporter: this.traceExporter,
         }).callModel(request);
@@ -495,10 +551,10 @@ export class AgentHarness {
     }
     createContext(opts) {
         const resolved = opts ?? {};
-        // `ContextImpl` takes the layers as `layers`, so both option spellings are
+        // `ContextImpl` takes the layers as `layers`, so the option spelling is
         // dropped from `rest` rather than spread through under the wrong name.
-        const { context: _context, memory: _memory, cwdInit, ...rest } = resolved;
-        const effectiveLayers = resolveContextOption(resolved) ?? this._contextLayers;
+        const { contextLayers, cwdInit, ...rest } = resolved;
+        const effectiveLayers = contextLayers ?? this._contextLayers;
         const itemSchemas = buildItemSchemaRegistry({
             base: this.itemSchemas,
             layers: effectiveLayers,
@@ -651,7 +707,7 @@ export class AgentHarness {
         const ctx = this.createContext({
             items: historyItems,
             threadId,
-            context: this._contextLayers,
+            contextLayers: this._contextLayers,
         });
         const layers = ctx.layers ?? [];
         if (layers.length === 0) {
@@ -660,14 +716,32 @@ export class AgentHarness {
         try {
             await this.ensureLayersInit(ctx);
             const recallResults = await this.recallLayers(layers, '', ctx);
-            const layerOutputItems = recallResults.flatMap((r) => r.items);
-            if (layerOutputItems.length === 0) {
+            // Band the output the way a real turn would, but read-only: a preview
+            // must not pin, count churn, or age the epoch, or looking at a
+            // conversation would change what the next turn sends.
+            const banded = await prepareBandedView({
+                recallResults,
+                layers,
+                execCtx: contextToExecCtx(ctx),
+                store: this.contextCache,
+                config: this.config.contextCache,
+                instructions: undefined,
+                policy: this.config.projection ?? DEFAULT_PROJECTION,
+                systemPromptItems: [],
+                budgets: new Map(),
+                readOnly: true,
+            });
+            if (banded.anchorItems.length === 0 &&
+                banded.liveItems.length === 0 &&
+                banded.deltaItems.length === 0) {
                 return historyItems;
             }
             return assembleView({
                 systemPromptItems: [],
-                layerOutputItems,
+                layerOutputItems: banded.anchorItems,
                 historyItems,
+                liveLayerItems: banded.liveItems,
+                deltaItems: banded.deltaItems,
             });
         }
         finally {

package/dist/harness/deps/context.d.ts

@@ -1,2 +1,2 @@
 export type { LayerStateStore, RecallCache } from '@noetic-tools/context';
-export { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from '@noetic-tools/context';
+export { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createContextCacheStore, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from '@noetic-tools/context';

package/dist/harness/deps/context.js

@@ -1 +1 @@
-export { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from '@noetic-tools/context';
+export { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createContextCacheStore, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from '@noetic-tools/context';

package/dist/harness/deps/interpreter.d.ts

@@ -1,4 +1,5 @@
 export { collectAllTools, deduplicateTools } from '../../interpreter/collect-tools.js';
+export { prepareBandedView } from '../../interpreter/context-assembly.js';
 export { execute } from '../../interpreter/execute.js';
 export type { DetachedSpawnOverrides } from '../../interpreter/step-dispatcher.js';
 export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher.js';

package/dist/harness/deps/interpreter.js

@@ -1,4 +1,5 @@
 export { collectAllTools, deduplicateTools } from '../../interpreter/collect-tools.js';
+export { prepareBandedView } from '../../interpreter/context-assembly.js';
 export { execute } from '../../interpreter/execute.js';
 export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher.js';
 export { isFunctionCall } from '../../interpreter/typeguards.js';

package/dist/harness/deps/types.d.ts

@@ -1,4 +1,4 @@
-export type { ContextData, ContextLayer, ExecutionContext, ProjectionPolicy, StorageAdapter, } from '@noetic-tools/context';
-export type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, RecallLayerOutput, SessionScope, ShellAdapter, Span, SteeringDecision, Step, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, } from '@noetic-tools/types';
+export type { ContextCacheConfig, ContextCacheStore, ContextData, ContextLayer, ExecutionContext, ProjectionPolicy, StorageAdapter, } from '@noetic-tools/context';
+export type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaConfig, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, RecallLayerOutput, SessionScope, SessionUsage, ShellAdapter, Span, SteeringDecision, Step, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, } from '@noetic-tools/types';
 export { SteeringAction } from '@noetic-tools/types';
 export type { ZodType } from 'zod';

package/dist/harness/model-call.d.ts

@@ -10,7 +10,7 @@ interface StreamIdleWatchdog {
 /** @internal Create a watchdog that aborts `controller` when no
  *  {@link StreamIdleWatchdog.reset reset} is called within `timeoutMs`. When
  *  `timeoutMs <= 0`, returns an inert no-op so callers can always call `.reset()`
- *  / `.stop()` without a branch. Starts armed: the caller is responsible for
+ *  / `.stop()` without branching. Starts armed: the caller is responsible for
  *  `.stop()` in a `finally`. `onTimeout` runs before the abort so observers can
  *  emit a framework event with the original cause. Exported only for unit tests. */
 export declare function createStreamIdleWatchdog(timeoutMs: number, controller: AbortController, onTimeout?: () => void): StreamIdleWatchdog;