@noetic-tools/context 1.2.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.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.',
         });
     }
 }

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,7 +207,7 @@ 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',
@@ -228,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/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

@@ -13,18 +13,17 @@ 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

@@ -15,18 +15,17 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/context",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "Context layer system for Noetic agents: the ContextLayer contract, lifecycle, budget/projection machinery, and built-in layer implementations.",
   "license": "Apache-2.0",
@@ -44,7 +44,7 @@
     "zod": "^4.0.0"
   },
   "dependencies": {
-    "@noetic-tools/types": "^3.1.0",
+    "@noetic-tools/types": "^3.2.1",
     "zod": "^4.0.0"
   },
   "scripts": {