@noetic-tools/core 1.1.2 → 1.2.1

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

@@ -105,6 +105,13 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     readonly layerStateStore: LayerStateStore;
     /** Per-harness memoization cache for `recallMode: 'eventual'` layers. */
     readonly recallCache: RecallCache;
+    /**
+     * 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
+     * accumulated in-memory state by re-hydrating from storage). Keyed by
+     * `ctx.id` (the layer-state store's executionId).
+     */
+    private readonly initializedExecutions;
     readonly traceExporter: TraceExporter;
     /**
      * Long-lived shared cwd state. The same reference is seeded into every
@@ -143,6 +150,14 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     private initAndRun;
+    /**
+     * Idempotently run layer `init` hooks for `ctx` (keyed by `ctx.id`). Init
+     * MUST complete before any recall/store fires so init-bearing layers are not
+     * treated as disabled. Guarded so nested/repeated `run()` calls and the
+     * session turn path never re-init — re-init would re-hydrate from storage and
+     * clobber accumulated in-memory state.
+     */
+    private ensureLayersInit;
     detachedSpawn<I, O>(s: Step<ContextMemory, I, O>, input: I, parentCtx: Context, overrides?: DetachedSpawnOverrides): DetachedHandle<O>;
     createContext(opts?: {
         parent?: Context;

package/dist/harness/agent-harness.js

@@ -110,6 +110,13 @@ export class AgentHarness {
     layerStateStore;
     /** Per-harness memoization cache for `recallMode: 'eventual'` layers. */
     recallCache;
+    /**
+     * 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
+     * accumulated in-memory state by re-hydrating from storage). Keyed by
+     * `ctx.id` (the layer-state store's executionId).
+     */
+    initializedExecutions = new Set();
     traceExporter;
     /**
      * Long-lived shared cwd state. The same reference is seeded into every
@@ -346,17 +353,46 @@ export class AgentHarness {
     }
     //#endregion
     async run(s, input, ctx) {
+        // Populate the unified tool pool when an embedder drives a step directly on
+        // a bare `createContext()` context (the turn pipeline does this per turn).
+        // Without it, steps that resolve tools dynamically from `ctx.unifiedTools`
+        // — and any sub-agents spawned from them — would see no tools.
+        if (!ctx.unifiedTools && (s !== undefined || this.harnessTools.length > 0)) {
+            this.setUnifiedTools(ctx, [
+                ...collectAllTools(s),
+                ...this.harnessTools,
+            ]);
+        }
+        // Hydrate/recall/persist memory on the bare `run()` path too (issue #48):
+        // configuring `memory` + `storage` must "just work" without going through
+        // `execute()`/`seedSessionHistory`. Idempotent — see `ensureLayersInit`.
+        await this.ensureLayersInit(ctx);
         return execute(s, input, ctx);
     }
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     async initAndRun(s, input, ctx) {
+        await this.ensureLayersInit(ctx);
+        return execute(s, input, ctx);
+    }
+    /**
+     * Idempotently run layer `init` hooks for `ctx` (keyed by `ctx.id`). Init
+     * MUST complete before any recall/store fires so init-bearing layers are not
+     * treated as disabled. Guarded so nested/repeated `run()` calls and the
+     * session turn path never re-init — re-init would re-hydrate from storage and
+     * clobber accumulated in-memory state.
+     */
+    async ensureLayersInit(ctx) {
         const layers = ctx.layers;
         const storage = this.config.storage;
-        if (layers && layers.length > 0 && storage) {
-            await this.initLayers(layers, ctx, storage);
+        if (!layers || layers.length === 0 || !storage) {
+            return;
         }
-        return execute(s, input, ctx);
+        if (this.initializedExecutions.has(ctx.id)) {
+            return;
+        }
+        this.initializedExecutions.add(ctx.id);
+        await this.initLayers(layers, ctx, storage);
     }
     detachedSpawn(s, input, parentCtx, overrides) {
         return dispatchStepThroughAdapter(this, s, input, parentCtx, overrides);
@@ -528,6 +564,9 @@ export class AgentHarness {
         });
     }
     async disposeLayers(layers, ctx) {
+        // Drop the init guard so a deliberate dispose→run cycle re-hydrates from
+        // storage (disposeLayers also clears the layer-state store for this id).
+        this.initializedExecutions.delete(ctx.id);
         await disposeLayers({
             layers,
             ctx: this.toExecCtx(ctx),

package/dist/interpreter/execute-action.js

@@ -411,6 +411,19 @@ async function collectSpawnItems({ layers, parentExecutionCtx, childExecutionCtx
     });
     return spawnResults.flatMap((r) => r.items);
 }
+/** Adds a spawned child's accumulated token/cost usage to its parent. */
+function rollUpSpawnUsage(parent, child) {
+    if (!isMutableContext(parent)) {
+        return;
+    }
+    parent.tokens.input += child.tokens.input;
+    parent.tokens.output += child.tokens.output;
+    parent.tokens.total += child.tokens.total;
+    if (child.tokens.cached !== undefined) {
+        parent.tokens.cached = (parent.tokens.cached ?? 0) + child.tokens.cached;
+    }
+    parent.cost += child.cost;
+}
 export async function executeSpawn(step, input, ctx, executeStep, opts) {
     const baseCtx = frameworkCast(ctx);
     const layers = resolveLayersForSpawn(step, opts?.parentLayers);
@@ -441,12 +454,20 @@ export async function executeSpawn(step, input, ctx, executeStep, opts) {
             itemSchemas: opts?.itemSchemas,
         });
     }
-    // Build unified tool set for child from its step tree + layers
+    // Build unified tool set for child from its step tree + layers, plus the
+    // parent's unified tools. Sub-agents that read tools dynamically (via
+    // `ctx.unifiedTools`) otherwise lose the harness tool pool at the spawn
+    // boundary — a child whose `step.llm` resolves `tools` from context would
+    // see nothing. Inheriting the parent's tools keeps the harness toolset
+    // available across spawns; the child's own step/layer tools take precedence
+    // on name collision (dedup keeps the first occurrence), and children that
+    // need a restricted set filter explicitly.
     const childStepTools = collectAllTools(step.child);
     const childLayerTools = layers.length > 0 ? resolveLayerTools(layers, baseCtx.harness, baseCtx) : [];
     const childUnifiedTools = deduplicateTools([
         ...childStepTools,
         ...childLayerTools,
+        ...(baseCtx.unifiedTools ?? []),
     ]);
     // Create child context — empty by default, layers provide items via onSpawn.
     // `id: childId` keeps the ContextImpl's id in sync with the executionId
@@ -468,6 +489,12 @@ export async function executeSpawn(step, input, ctx, executeStep, opts) {
     try {
         // Execute the child step
         const childOutput = await executeStep(step.child, input, frameworkCast(childCtx));
+        // Roll the child's token/cost usage up into the parent. A sub-agent's
+        // spend is the parent's spend; without this it would be stranded on the
+        // child context and invisible to `ctx.tokens` / `ctx.cost` / until.maxCost.
+        // Because every spawn boundary rolls up, nested sub-agents propagate to the
+        // root recursively.
+        rollUpSpawnUsage(baseCtx, childCtx);
         // Pipeline result through layer onReturn hooks
         if (!hasLayers || !parentExecutionCtx) {
             return childOutput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/core",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "type": "module",
   "description": "Step primitives, interpreter, runtime, and memory layer contract for Noetic agents.",
   "license": "Apache-2.0",