@noetic-tools/context 1.8.0 → 1.10.0

package/dist/context/layer-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { ContextLayer, DecisionRecord, ExecutionContext, Item, ItemLog, ItemSchemaRegistry, LLMResponse, ScopedStorage, SteeringDecision, StorageAdapter } from '@noetic-tools/types';
+import type { ContextLayer, DecisionRecord, ExecutionContext, Item, ItemLog, ItemSchemaRegistry, LLMResponse, OnSteerParams, ScopedStorage, SteeringDecision, SteerVerdict, StorageAdapter } from '@noetic-tools/types';
 import type { LiveChild } from './parent-updates.js';
 export interface LayerStateStore {
     get<T>(executionId: string, layerId: string): T | undefined;
@@ -154,6 +154,11 @@ interface AfterModelCallLayersParams {
     ctx: ExecutionContext;
     store: LayerStateStore;
 }
+interface OnSteerLayersParams extends Pick<OnSteerParams, 'steer' | 'point' | 'action' | 'pendingCalls'> {
+    layers: ContextLayer[];
+    ctx: ExecutionContext;
+    store: LayerStateStore;
+}
 interface ProjectHistoryLayersParams {
     layers: ContextLayer[];
     items: ReadonlyArray<Item>;
@@ -274,6 +279,12 @@ export declare function returnLayers<T>({ layers, stepId, parentCtx, childCtx, c
 export declare function completeLayers({ layers, ctx, log, outcome, store, }: CompleteLayersParams): Promise<void>;
 export declare function beforeToolCallLayers({ layers, toolName, toolArgs, callId, ctx, store, }: BeforeToolCallLayersParams): Promise<SteeringDecision>;
 export declare function afterModelCallLayers({ layers, response, ctx, store, }: AfterModelCallLayersParams): Promise<SteeringDecision>;
+/**
+ * Run a steer through every layer's `onSteer` hook in slot order. Each layer
+ * sees the action and items the previous layer left, so the last layer to
+ * speak wins. A hook that throws or times out leaves both unchanged.
+ */
+export declare function onSteerLayers({ layers, steer, point, action, pendingCalls, ctx, store, }: OnSteerLayersParams): Promise<SteerVerdict>;
 /**
  * Run history items through every layer's `projectHistory` hook in slot order.
  * Each layer receives the previous layer's output. Storage (`itemLog`) is

package/dist/context/layer-lifecycle.js

@@ -889,6 +889,70 @@ export async function afterModelCallLayers({ layers, response, ctx, store, }) {
     }
     return mostRestrictive(decisions);
 }
+/**
+ * Run a steer through every layer's `onSteer` hook in slot order. Each layer
+ * sees the action and items the previous layer left, so the last layer to
+ * speak wins. A hook that throws or times out leaves both unchanged.
+ */
+export async function onSteerLayers({ layers, steer, point, action, pendingCalls, ctx, store, }) {
+    const sorted = [
+        ...layers,
+    ].sort((a, b) => a.slot - b.slot);
+    let verdict = {
+        action,
+        items: steer.items,
+    };
+    for (const layer of sorted) {
+        if (!layer.hooks.onSteer) {
+            continue;
+        }
+        const state = store.get(ctx.executionId, layer.id);
+        if (isLayerDisabled({
+            store,
+            executionId: ctx.executionId,
+            layer,
+            state,
+        })) {
+            await traceSkipped(ctx, layer.id, 'onSteer');
+            continue;
+        }
+        const onSteer = layer.hooks.onSteer;
+        const current = verdict;
+        try {
+            const result = await callHook({
+                ctx,
+                layerId: layer.id,
+                hook: 'onSteer',
+                timeout: layer.timeouts?.onSteer ?? 5e3,
+                run: () => onSteer({
+                    steer: {
+                        id: steer.id,
+                        items: current.items,
+                    },
+                    point,
+                    action: current.action,
+                    pendingCalls,
+                    ctx,
+                    state,
+                }),
+            });
+            if (result.state !== undefined) {
+                store.set(ctx.executionId, layer.id, result.state);
+            }
+            verdict = {
+                action: result.action ?? current.action,
+                items: result.items ?? current.items,
+            };
+        }
+        catch (e) {
+            if (e instanceof NoeticConfigError) {
+                throw e;
+            }
+            store.diagnostic(layer.id, 'onSteer', e);
+        }
+    }
+    return verdict;
+}
 /**
  * Run history items through every layer's `projectHistory` hook in slot order.
  * Each layer receives the previous layer's output. Storage (`itemLog`) is

package/dist/context/layers/plan-prompts.js

@@ -290,7 +290,7 @@ ${structure.join('\n')}
 
 **Shaping it**
 - Keep the tree the user reviews SMALL — about seven top-level nodes, readable at a glance. Push the mechanics down.
-- Factor detail into named workflows: define each with \`plan/setWorkflow\` \`{ "name": "<slug>", "document": {...} }\` and point at it with \`{ "kind": "subflow", "id": "...", "ref": "<slug>" }\`. Named workflows may reference each other but must not form a cycle, and every ref must resolve or the exit is rejected.
+- Factor detail into named workflows: define each with \`plan/setWorkflow\` \`{ "name": "<slug>", "document": {...} }\` and point at it with \`{ "kind": "subflow", "id": "...", "ref": "<slug>" }\`. Named workflows may reference each other, and may recurse (a workflow may call itself) as long as a branch eventually stops the recursion; every ref must resolve or the exit is rejected.
 - Fan out work that is genuinely independent; sequence work where one step needs the last one's output. Do not fan out for the look of it.
 - Prefer \`invokeTool\` over \`callModel\` wherever the step is deterministic. A model turn that always does the same thing is a slow, expensive tool call.
 - Always give a \`loop\` a \`maxIterations\`. Without one it stops at a hard ceiling of 1000 and fails the step.`;

package/dist/context/layers/plan.js

@@ -161,49 +161,6 @@ function findDanglingRefs(state) {
     }
     return dangling;
 }
-/**
- * Detects a reference cycle among named workflows (self-reference included).
- * Returns the cycle path for the rejection message, or null when acyclic.
- */
-function findWorkflowCycle(workflows) {
-    const edges = new Map();
-    for (const [name, doc] of Object.entries(workflows)) {
-        edges.set(name, collectSubflowRefs(doc).filter((ref) => ref in workflows));
-    }
-    const visiting = new Set();
-    const done = new Set();
-    const path = [];
-    const visit = (name) => {
-        if (done.has(name)) {
-            return null;
-        }
-        if (visiting.has(name)) {
-            return [
-                ...path.slice(path.indexOf(name)),
-                name,
-            ];
-        }
-        visiting.add(name);
-        path.push(name);
-        for (const next of edges.get(name) ?? []) {
-            const cycle = visit(next);
-            if (cycle) {
-                return cycle;
-            }
-        }
-        path.pop();
-        visiting.delete(name);
-        done.add(name);
-        return null;
-    };
-    for (const name of edges.keys()) {
-        const cycle = visit(name);
-        if (cycle) {
-            return cycle;
-        }
-    }
-    return null;
-}
 function buildAllowedTools(config) {
     if (!config?.additionalAllowedTools?.length) {
         return ALLOWED_TOOLS_IN_PLAN_MODE;
@@ -462,13 +419,6 @@ async function executeExitPlanMode(args, state, options) {
             state,
         };
     }
-    const cycle = findWorkflowCycle(state.workflows);
-    if (cycle) {
-        return {
-            result: `Cannot execute: workflows reference each other in a cycle: ${cycle.join(' -> ')}. Break the cycle before exiting.`,
-            state,
-        };
-    }
     if (options.onExit) {
         const { approved } = await options.onExit(state);
         if (!approved) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/context",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "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.9.0",
+    "@noetic-tools/types": "^3.13.0",
     "zod": "^4.0.0"
   },
   "scripts": {