@seanhogg/builderforce-memory 2026.6.35 → 2026.6.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanhogg/builderforce-memory",
-  "version": "2026.6.35",
+  "version": "2026.6.39",
   "description": "BuilderForce Agent Memory — runtime layer. SSM execution, Transformer orchestration, online distillation, hybrid RAG retrieval, and persistent agent memory for BuilderForce.ai agents.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -53,7 +53,7 @@
   },
   "homepage": "https://github.com/SeanHogg/builderforce-memory/tree/main/packages/memory#readme",
   "peerDependencies": {
-    "@seanhogg/builderforce-memory-engine": "^2026.6.35"
+    "@seanhogg/builderforce-memory-engine": "^2026.6.39"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
@@ -67,7 +67,7 @@
     "ts-jest": "^29.2.0",
     "typescript": "^6.0.3",
     "@typescript/native-preview": "7.0.0-dev.20260627.2",
-    "@seanhogg/builderforce-memory-engine": "2026.6.35"
+    "@seanhogg/builderforce-memory-engine": "2026.6.39"
   },
   "jest": {
     "preset": "ts-jest/presets/default-esm",
@@ -85,6 +85,7 @@
             "strict": false,
             "esModuleInterop": true,
             "skipLibCheck": true,
+            "rootDir": "..",
             "types": [
               "@webgpu/types",
               "jest"
@@ -94,12 +95,14 @@
       ]
     },
     "moduleNameMapper": {
+      "^@seanhogg/builderforce-memory-engine$": "<rootDir>/../memory-engine/src/index.ts",
       "^(\\.{1,2}/.*)\\.js$": "$1"
     },
     "collectCoverageFrom": [
       "src/**/*.ts",
       "!src/**/index.ts",
-      "!src/session/**"
+      "!src/session/**",
+      "!src/limbic/LimbicSession.ts"
     ],
     "coverageThreshold": {
       "global": {

package/src/index.ts

@@ -217,9 +217,12 @@ export {
     BUILTIN_STEPS,
     AGENTIC_SEVEN_LAYER,
     TRAIN_LLM,
+    TEACH_CODE,
     WORKFLOW_TEMPLATES,
     getTemplate,
     cloneTemplate,
+    analyzeCode,
+    runJsCases,
 } from './workflow/index.js';
 export type {
     WorkflowConfig,
@@ -228,6 +231,9 @@ export type {
     StepFactory,
     WorkflowValidationError,
     RunWorkflowOptions,
+    CodeAnalysis,
+    CodeCase,
+    CodeEvalResult,
 } from './workflow/index.js';
 
 // ── Publish (ship an engine model export to HF / local folder) ──────────────────

package/src/limbic/LimbicSession.ts

@@ -24,10 +24,15 @@ import {
   createBindGroup,
   dispatchKernel,
   readBuffer,
+  personalitySetpoint,
+  clampState,
+  neutralState,
+  LIMBIC_STATE_DIM,
   type LimbicModelConfig,
   type LimbicForward,
   type LimbicSample,
   type LimbicTrainOptions,
+  type PersonalityTraits,
 } from "@seanhogg/builderforce-memory-engine";
 
 import { saveToIndexedDB, loadFromIndexedDB } from "../session/persistence.js";
@@ -49,6 +54,18 @@ export interface LimbicSessionOptions {
   modelConfig?: Partial<LimbicModelConfig>;
   /** Deterministic init seed. */
   seed?: number;
+  /**
+   * The agent's static personality traits (0..100). Mapped to the resting affective
+   * SETPOINT the learned dynamics ride on top of, so training + relaxation happen
+   * around the personality baseline instead of neutral ("personality = setpoints,
+   * limbic = dynamics"). Ignored when {@link personalitySetpoint} is given.
+   */
+  personalityTraits?: PersonalityTraits;
+  /**
+   * An explicit 8-dim resting setpoint (e.g. one already derived by the runtime's
+   * `deriveLimbicSetpoints`). Overrides {@link personalityTraits}. Clamped to bounds.
+   */
+  personalitySetpoint?: ArrayLike<number>;
 }
 
 interface StepBuffers {
@@ -64,6 +81,11 @@ export class LimbicSession {
   readonly trainer: LimbicTrainer;
   readonly device: GPUDevice | null;
   readonly gpuMode: LimbicGpuMode;
+  /** The personality-conditioned resting setpoint (8-dim). NEUTRAL when no
+   *  personality was supplied. The homeostatic baseline the learned dynamics
+   *  settle toward — see {@link baselineState}. Mutable via {@link setSetpoint} so a
+   *  long-lived service can re-point it when the active personas change. */
+  setpoint: Float32Array;
   private readonly _name: string;
   private readonly _idbFactory: IDBFactory | undefined;
 
@@ -80,6 +102,7 @@ export class LimbicSession {
     gpuMode: LimbicGpuMode,
     name: string,
     idbFactory: IDBFactory | undefined,
+    setpoint: Float32Array,
   ) {
     this.model = model;
     this.trainer = trainer;
@@ -87,6 +110,32 @@ export class LimbicSession {
     this.gpuMode = gpuMode;
     this._name = name;
     this._idbFactory = idbFactory;
+    this.setpoint = setpoint;
+  }
+
+  /**
+   * A fresh copy of the personality-conditioned resting state. Seed training-sample
+   * states and initial affect from this so the learned dynamics move AROUND the
+   * agent's personality baseline rather than a fixed neutral. NEUTRAL when the
+   * session was created with no personality.
+   */
+  baselineState(): Float32Array {
+    return Float32Array.from(this.setpoint);
+  }
+
+  /**
+   * Re-point the resting setpoint after construction — e.g. a long-lived service
+   * recomputing it when the active personas change. An explicit 8-dim vector wins;
+   * else the traits are mapped; else neutral. Clamped to bounds.
+   */
+  setSetpoint(traits?: PersonalityTraits, explicit?: ArrayLike<number>): void {
+    if (explicit && explicit.length >= LIMBIC_STATE_DIM) {
+      this.setpoint = clampState(Float32Array.from(explicit));
+    } else if (traits) {
+      this.setpoint = personalitySetpoint(traits);
+    } else {
+      this.setpoint = neutralState();
+    }
   }
 
   static async create(options: LimbicSessionOptions = {}): Promise<LimbicSession> {
@@ -129,7 +178,18 @@ export class LimbicSession {
       model.loadWeights(options.checkpointBuffer);
     }
     const trainer = new LimbicTrainer(model, device);
-    return new LimbicSession(model, trainer, device, gpuMode, options.name ?? "limbic-default", options.idbFactory);
+    // Resolve the resting setpoint: an explicit 8-dim vector wins; else map the
+    // personality traits; else neutral. This is where the STATIC personality enters
+    // the (dynamic, trainable) limbic system.
+    let setpoint: Float32Array;
+    if (options.personalitySetpoint && options.personalitySetpoint.length >= LIMBIC_STATE_DIM) {
+      setpoint = clampState(Float32Array.from(options.personalitySetpoint));
+    } else if (options.personalityTraits) {
+      setpoint = personalitySetpoint(options.personalityTraits);
+    } else {
+      setpoint = neutralState();
+    }
+    return new LimbicSession(model, trainer, device, gpuMode, options.name ?? "limbic-default", options.idbFactory, setpoint);
   }
 
   /** One affect step. Uses the GPU kernel when a device is available, else CPU. */

package/src/workflow/code-eval.ts

@@ -0,0 +1,143 @@
+/**
+ * workflow/code-eval.ts — dependency-free code-validity + execution-reward checks.
+ *
+ * These power the code-specific BUILD diagnostics that grade what Evermind's
+ * generator produces when we teach it to program:
+ *   • {@link analyzeCode}  — structural validity (balanced delimiters/strings) +
+ *                            an optional JS parse. The portable "does this look
+ *                            like valid code" gate.
+ *   • {@link runJsCases}   — execution-grounded reward: run generated JS against
+ *                            test cases and score the pass-rate. Code's signal is
+ *                            that it RUNS — this turns that into a number.
+ *
+ * Both are zero-dependency (no AST library) so they run in the same WebGPU/TS
+ * runtime as the rest of the engine. Execution uses the `Function` constructor —
+ * a heuristic reward sandbox, NOT a security boundary; only feed it code from a
+ * trusted teacher / the model under training.
+ */
+
+const OPEN: Record<string, string> = { ")": "(", "]": "[", "}": "{" };
+
+export interface CodeAnalysis {
+  /** 0..1 structural-validity score (1 = delimiters and strings all balanced). */
+  score: number;
+  /** True when every bracket/brace/paren and string literal closes cleanly. */
+  balanced: boolean;
+  /** For language="js": whether the source parses (Function constructor). undefined otherwise. */
+  jsParse?: boolean;
+}
+
+/**
+ * Score how structurally valid `code` is: walk the source tracking string state
+ * (so brackets inside strings are ignored) and a delimiter stack. A clean parse
+ * scores 1; each unmatched/mismatched delimiter or unterminated string lowers it.
+ */
+export function analyzeCode(code: string, language = "js"): CodeAnalysis {
+  const stack: string[] = [];
+  let mismatches = 0;
+  let delims = 0;
+  let inString: string | null = null; // the opening quote char, or null
+  let escaped = false;
+
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i]!;
+    if (inString) {
+      if (escaped) { escaped = false; continue; }
+      if (ch === "\\") { escaped = true; continue; }
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") { inString = ch; continue; }
+    if (ch === "(" || ch === "[" || ch === "{") { stack.push(ch); delims++; continue; }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      delims++;
+      if (stack.pop() !== OPEN[ch]) mismatches++;
+    }
+  }
+  // Anything left open is an unmatched delimiter; an open string is one more fault.
+  mismatches += stack.length;
+  const faults = mismatches + (inString ? 1 : 0);
+  const denom = Math.max(1, delims + (inString ? 1 : 0));
+  const balanced = faults === 0;
+  const score = balanced ? 1 : Math.max(0, 1 - faults / denom);
+
+  const analysis: CodeAnalysis = { score, balanced };
+  if (language === "js" || language === "ts" || language === "javascript" || language === "typescript") {
+    analysis.jsParse = jsParses(code);
+  }
+  return analysis;
+}
+
+/** True when `code` parses as JS (Function constructor parses but does not run). */
+function jsParses(code: string): boolean {
+  try {
+    // eslint-disable-next-line no-new-func
+    new Function(code);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface CodeCase {
+  /** An expression to evaluate after the code is loaded, e.g. "add(2, 3)". */
+  call: string;
+  /** The expected result (deep-equal compared). */
+  expect: unknown;
+}
+
+export interface CodeEvalResult {
+  passed: number;
+  total: number;
+  /** passed / total (0 when there are no cases). */
+  passRate: number;
+  /** A whole-program error (e.g. syntax error) that failed every case, if any. */
+  error?: string;
+}
+
+/**
+ * Load `code` (which defines functions) and evaluate each case's `call`
+ * expression, comparing the result to `expect`. A syntax error in `code` fails
+ * every case. Per-case runtime errors fail only that case.
+ *
+ * NOTE: heuristic reward sandbox, not a security boundary — see file header.
+ */
+export function runJsCases(code: string, cases: CodeCase[]): CodeEvalResult {
+  const total = cases.length;
+  if (total === 0) return { passed: 0, total: 0, passRate: 0 };
+
+  let passed = 0;
+  for (const c of cases) {
+    try {
+      // Code defines functions (hoisted); the trailing return evaluates the call.
+      // eslint-disable-next-line no-new-func
+      const fn = new Function(`${code}\n;return (${c.call});`);
+      const actual = fn();
+      if (deepEqual(actual, c.expect)) passed++;
+    } catch (err) {
+      // A syntax error throws at construction for ALL cases — report it once.
+      if (err instanceof SyntaxError) {
+        return { passed: 0, total, passRate: 0, error: err.message };
+      }
+      // Runtime error → this case simply fails.
+    }
+  }
+  return { passed, total, passRate: passed / total };
+}
+
+/** Structural deep equality good enough for JSON-shaped test expectations. */
+function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b || a === null || b === null) return false;
+  if (typeof a !== "object") return Object.is(a, b);
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  const ao = a as Record<string, unknown>;
+  const bo = b as Record<string, unknown>;
+  const ak = Object.keys(ao);
+  const bk = Object.keys(bo);
+  if (ak.length !== bk.length) return false;
+  return ak.every((k) => deepEqual(ao[k], bo[k]));
+}

package/src/workflow/index.ts

@@ -6,14 +6,22 @@
 
 export type { WorkflowConfig, WorkflowStepConfig, StepTypeInfo, StepFactory } from "./types.js";
 export { StepTypeRegistry, createDefaultRegistry, defaultStepRegistry } from "./registry.js";
-export { BUILTIN_STEPS } from "./steps.js";
+export { BUILTIN_STEPS, selectBestCandidate, stripCodeFences } from "./steps.js";
 export {
   AGENTIC_SEVEN_LAYER,
   TRAIN_LLM,
+  TEACH_CODE,
   WORKFLOW_TEMPLATES,
   getTemplate,
   cloneTemplate,
 } from "./templates.js";
+export {
+  analyzeCode,
+  runJsCases,
+  type CodeAnalysis,
+  type CodeCase,
+  type CodeEvalResult,
+} from "./code-eval.js";
 export {
   compileWorkflow,
   validateWorkflow,