@seanhogg/builderforce-memory-engine 2026.10.1 → 2026.10.2

package/src/index.ts

@@ -43,6 +43,7 @@ export {
     buildDeltaLearnPayload,
     decodeDeltaPayload,
     deltaUnusableReason,
+    deltaTargetMismatch,
     MAX_DELTA_B64_CHARS,
     mergeCheckpointDiffs,
     mergeCheckpointDiffsGated,
@@ -63,6 +64,7 @@ export type {
     AdaptTokenizer,
     DeltaLearnPayload,
     DeltaParseResult,
+    DeltaParseOptions,
     MergeResult,
     GatedMergeResult,
     MergeGateOptions,

package/src/limbic/limbic_model.ts

@@ -28,6 +28,7 @@
  * (experience, state) → affect pair is close to an independent regression.
  */
 
+import { sigmoid } from "../training/cpu_ops.js";
 import { SeededRng } from "../utils/rng.js";
 import { quantizeFp16, dequantizeFp16 } from "../utils/quantization.js";
 import { LIMBIC_STATE_DIM } from "./regions.js";
@@ -86,10 +87,6 @@ const MAGIC = 0x4c4d4243; // "LMBC"
 /** Fixed default init seed — reproducible byte-identical cold start across machines. */
 export const DEFAULT_LIMBIC_SEED = 0x11b1c5ee;
 
-function sigmoid(x: number): number {
-  return 1 / (1 + Math.exp(-x));
-}
-
 export class LimbicModel {
   readonly config: Required<Omit<LimbicModelConfig, "seed">>;
 

package/src/limbic/limbic_trainer.ts

@@ -1,91 +1,91 @@
-/**
- * limbic_trainer.ts – LimbicTrainer: gradient-based training for the LimbicModel.
- *
- * Trains the affect head to predict affect deltas and reward from
- * (experience embedding, current state) pairs, using full-batch gradient
- * descent with AdamW — through the shared {@link HeadTrainer} (`ml/head_trainer.ts`),
- * which runs the optimiser step on the GPU via WEIGHT_UPDATE_WGSL when a device is
- * supplied and on a numerically-equivalent CPU AdamW otherwise. This file is only
- * the limbic registration: the head adapter and the public trainer surface.
- *
- * The objective is MSE (regression), not the cross-entropy used by the
- * language-model {@link MambaTrainer} — a limbic experience has continuous
- * targets, not a next-token distribution.
- */
-
-import { HeadTrainer, type HeadTrainOptions, type TrainableHead } from "../ml/head_trainer.js";
-import type { LimbicModel, LimbicParam } from "./limbic_model.js";
-
-/** One training example: an experience and the affect change it should produce. */
-export interface LimbicSample {
-  /** Experience embedding (length = model.inputDim). */
-  input: ArrayLike<number>;
-  /** Affective state at the time of the experience (length = model.stateDim). */
-  state: ArrayLike<number>;
-  /** Observed affect delta target in (-1, 1) per state dim (length = model.stateDim). */
-  deltaTarget: ArrayLike<number>;
-  /** Observed scalar reward for the experience. */
-  reward: number;
-}
-
-/** The limbic trainer's options are the shared head trainer's. */
-export type LimbicTrainOptions = HeadTrainOptions;
-
-/**
- * The limbic model as a {@link TrainableHead}. Each sample is one experience
- * appraisal: cross-experience memory flows through the affective state `s` (fed
- * back by the runtime), not through the hidden scratch `h`, so the hidden state
- * resets per sample. This also makes BPTT(1) exact — there is no truncated carry.
- */
-export function limbicHead(model: LimbicModel): TrainableHead<LimbicSample> {
-  return {
-    parameters: (): LimbicParam[] => model.parameters(),
-    gradients: (): LimbicParam[] => model.gradients(),
-    zeroGrad: () => model.zeroGrad(),
-    accumulate: (s) =>
-      model.backwardStep(s.input, model.initHidden(), s.state, s.deltaTarget, s.reward).loss,
-    loss: (s) => {
-      const { rewardWeight } = model.config;
-      const f = model.forward(s.input, model.initHidden(), s.state);
-      let loss = 0;
-      for (let k = 0; k < f.delta.length; k++) {
-        const d = f.delta[k]! - (s.deltaTarget[k] ?? 0);
-        loss += 0.5 * d * d;
-      }
-      const rd = f.reward - s.reward;
-      loss += 0.5 * rewardWeight * rd * rd;
-      return loss;
-    },
-  };
-}
-
-/** Thin registration of the limbic head over the shared {@link HeadTrainer}. */
-export class LimbicTrainer {
-  readonly model: LimbicModel;
-  readonly device: GPUDevice | null;
-  private readonly _trainer: HeadTrainer<LimbicSample>;
-
-  constructor(model: LimbicModel, device: GPUDevice | null = null) {
-    this.model = model;
-    this.device = device;
-    this._trainer = new HeadTrainer(limbicHead(model), device, "LimbicTrainer");
-  }
-
-  /** Whether the optimiser step runs on the GPU. */
-  get gpuTraining(): boolean {
-    return this._trainer.gpuTraining;
-  }
-
-  /**
-   * Train on a batch of samples for `epochs` passes. Returns the per-epoch mean
-   * loss (monotonically decreasing on a learnable mapping).
-   */
-  train(samples: LimbicSample[], opts: LimbicTrainOptions = {}): Promise<number[]> {
-    return this._trainer.train(samples, opts);
-  }
-
-  /** Mean MSE loss over samples (no weight update). Hidden resets per sample. */
-  evaluate(samples: LimbicSample[]): number {
-    return this._trainer.evaluate(samples);
-  }
-}
+/**
+ * limbic_trainer.ts – LimbicTrainer: gradient-based training for the LimbicModel.
+ *
+ * Trains the affect head to predict affect deltas and reward from
+ * (experience embedding, current state) pairs, using full-batch gradient
+ * descent with AdamW — through the shared {@link HeadTrainer} (`ml/head_trainer.ts`),
+ * which runs the optimiser step on the GPU via WEIGHT_UPDATE_WGSL when a device is
+ * supplied and on a numerically-equivalent CPU AdamW otherwise. This file is only
+ * the limbic registration: the head adapter and the public trainer surface.
+ *
+ * The objective is MSE (regression), not the cross-entropy used by the
+ * language-model {@link MambaTrainer} — a limbic experience has continuous
+ * targets, not a next-token distribution.
+ */
+
+import { HeadTrainer, type HeadTrainOptions, type TrainableHead } from "../ml/head_trainer.js";
+import type { LimbicModel, LimbicParam } from "./limbic_model.js";
+
+/** One training example: an experience and the affect change it should produce. */
+export interface LimbicSample {
+  /** Experience embedding (length = model.inputDim). */
+  input: ArrayLike<number>;
+  /** Affective state at the time of the experience (length = model.stateDim). */
+  state: ArrayLike<number>;
+  /** Observed affect delta target in (-1, 1) per state dim (length = model.stateDim). */
+  deltaTarget: ArrayLike<number>;
+  /** Observed scalar reward for the experience. */
+  reward: number;
+}
+
+/** The limbic trainer's options are the shared head trainer's. */
+export type LimbicTrainOptions = HeadTrainOptions;
+
+/**
+ * The limbic model as a {@link TrainableHead}. Each sample is one experience
+ * appraisal: cross-experience memory flows through the affective state `s` (fed
+ * back by the runtime), not through the hidden scratch `h`, so the hidden state
+ * resets per sample. This also makes BPTT(1) exact — there is no truncated carry.
+ */
+export function limbicHead(model: LimbicModel): TrainableHead<LimbicSample> {
+  return {
+    parameters: (): LimbicParam[] => model.parameters(),
+    gradients: (): LimbicParam[] => model.gradients(),
+    zeroGrad: () => model.zeroGrad(),
+    accumulate: (s) =>
+      model.backwardStep(s.input, model.initHidden(), s.state, s.deltaTarget, s.reward).loss,
+    loss: (s) => {
+      const { rewardWeight } = model.config;
+      const f = model.forward(s.input, model.initHidden(), s.state);
+      let loss = 0;
+      for (let k = 0; k < f.delta.length; k++) {
+        const d = f.delta[k]! - (s.deltaTarget[k] ?? 0);
+        loss += 0.5 * d * d;
+      }
+      const rd = f.reward - s.reward;
+      loss += 0.5 * rewardWeight * rd * rd;
+      return loss;
+    },
+  };
+}
+
+/** Thin registration of the limbic head over the shared {@link HeadTrainer}. */
+export class LimbicTrainer {
+  readonly model: LimbicModel;
+  readonly device: GPUDevice | null;
+  private readonly _trainer: HeadTrainer<LimbicSample>;
+
+  constructor(model: LimbicModel, device: GPUDevice | null = null) {
+    this.model = model;
+    this.device = device;
+    this._trainer = new HeadTrainer(limbicHead(model), device, "LimbicTrainer");
+  }
+
+  /** Whether the optimiser step runs on the GPU. */
+  get gpuTraining(): boolean {
+    return this._trainer.gpuTraining;
+  }
+
+  /**
+   * Train on a batch of samples for `epochs` passes. Returns the per-epoch mean
+   * loss (monotonically decreasing on a learnable mapping).
+   */
+  train(samples: LimbicSample[], opts: LimbicTrainOptions = {}): Promise<number[]> {
+    return this._trainer.train(samples, opts);
+  }
+
+  /** Mean MSE loss over samples (no weight update). Hidden resets per sample. */
+  evaluate(samples: LimbicSample[]): number {
+    return this._trainer.evaluate(samples);
+  }
+}

package/src/ml/classical/anomaly_composite.ts

@@ -0,0 +1,46 @@
+/**
+ * ml/classical/anomaly_composite.ts — robust z and EWMA as ONE anomaly engine.
+ *
+ * Two detectors, one answer: robust z (median/MAD over the whole history — "far
+ * from normal") and EWMA (the recent trend — "drifting away from lately"). The
+ * score is the larger of the two normalised scores, so either one can flag. It is
+ * one engine because it is one fitted thing: a task that lists it gets back exactly
+ * what it stores under `local:classical:anomaly-composite`.
+ */
+import type { MlPrediction, MlPredictor, MlSample } from "../types.js";
+import { EwmaModel, fitEwma, type EwmaOptions } from "./ewma.js";
+import { anomalyConfidence, fitRobustZ, RobustZModel, type RobustZOptions } from "./robust_z.js";
+
+export interface AnomalyCompositeOptions {
+  robustZ?: RobustZOptions;
+  ewma?: EwmaOptions;
+}
+
+export class AnomalyCompositeModel implements MlPredictor {
+  constructor(
+    readonly population: RobustZModel,
+    readonly trend: EwmaModel,
+  ) {}
+
+  /** Per feature, per detector: z / threshold (≥ 1 = out of range). */
+  featureScores(x: ArrayLike<number>): { population: number; trend: number }[] {
+    const pz = this.population.zScores(x);
+    const tz = this.trend.zScores(x);
+    return pz.map((z, i) => ({ population: z / this.population.threshold, trend: tz[i]! / this.trend.threshold }));
+  }
+
+  /** Fold a finished, non-anomalous observation into the trend. */
+  observe(x: ArrayLike<number>): void {
+    this.trend.update(x);
+  }
+
+  predict(x: Float32Array): MlPrediction {
+    const score = Math.max(this.population.predict(x).scores[0]!, this.trend.predict(x).scores[0]!);
+    return { scores: [score], confidence: anomalyConfidence(score) };
+  }
+}
+
+/** Fit both detectors on a chronological history (feature vectors, oldest first). */
+export function fitAnomalyComposite(samples: readonly MlSample[], opts: AnomalyCompositeOptions = {}): AnomalyCompositeModel {
+  return new AnomalyCompositeModel(fitRobustZ(samples, opts.robustZ), fitEwma(samples, opts.ewma));
+}

package/src/ml/classical/ewma.ts

@@ -5,6 +5,8 @@
  * Per feature, over the history IN ORDER: diff = x − μ; μ += α·diff;
  * σ² = (1 − α)(σ² + α·diff²). A new point scores z = |x − μ| / σ against the
  * state BEFORE it is folded in. Prediction: `scores[0] = max_i z_i / threshold`.
+ * σ is floored like robust z's scale: a fraction of |μ|, and `minScale` in absolute
+ * units — σ² starts at 0, so a constant history would otherwise flag any change.
  */
 import type { MlPrediction, MlPredictor, MlSample } from "../types.js";
 import { featureDim } from "./math.js";
@@ -17,6 +19,8 @@ export interface EwmaOptions {
   threshold?: number;
   /** Smallest σ per feature, as a fraction of |μ| (plus 1e-9). Default 0.01. */
   minScaleFraction?: number;
+  /** Smallest σ per feature in absolute feature units. Default 0 (see `RobustZOptions.minScale`). */
+  minScale?: number;
 }
 
 export class EwmaModel implements MlPredictor {
@@ -26,13 +30,14 @@ export class EwmaModel implements MlPredictor {
     readonly alpha: number,
     readonly threshold: number,
     readonly minScaleFraction: number,
+    readonly minScale: number = 0,
   ) {
     if (!(alpha > 0 && alpha <= 1)) throw new Error(`EwmaModel: alpha must be in (0, 1] (got ${alpha})`);
   }
 
   zScores(x: ArrayLike<number>): number[] {
     return Array.from(this.mean, (m, i) => {
-      const sd = Math.max(Math.sqrt(this.variance[i]!), this.minScaleFraction * Math.abs(m) + 1e-9);
+      const sd = Math.max(Math.sqrt(this.variance[i]!), this.minScaleFraction * Math.abs(m) + 1e-9, this.minScale);
       return Math.abs((x[i] ?? 0) - m) / sd;
     });
   }
@@ -62,6 +67,7 @@ export function fitEwma(samples: readonly MlSample[], opts: EwmaOptions = {}): E
     opts.alpha ?? 0.3,
     opts.threshold ?? 3,
     opts.minScaleFraction ?? 0.01,
+    opts.minScale ?? 0,
   );
   for (let i = 1; i < samples.length; i++) model.update(samples[i]!.x);
   return model;

package/src/ml/classical/gbm.ts

@@ -1,143 +1,144 @@
-/**
- * ml/classical/gbm.ts — a small gradient-boosted tree ensemble.
- *
- * Depth-limited regression trees fitted to the loss gradient, one after another,
- * shrunk by a learning rate. Objectives: `binary` (log-loss, Newton leaf values)
- * and `regression` (squared error). Exhaustive split search over midpoints —
- * fine for the catalog's small numeric feature sets, not for wide embeddings.
- */
-import type { MlPrediction, MlPredictor, MlSample } from "../types.js";
-import { featureDim, sigmoid, type Vec } from "./math.js";
-
-export type GbmObjective = "binary" | "regression";
-
-export interface GbmOptions {
-  objective?: GbmObjective;
-  trees?: number;
-  maxDepth?: number;
-  learningRate?: number;
-  /** Minimum summed sample weight in a leaf. Default 1. */
-  minLeafWeight?: number;
-  /** L2 on leaf values (Newton denominator). Default 1. */
-  lambda?: number;
-}
-
-type RTree = { value: number } | { feature: number; split: number; left: RTree; right: RTree };
-
-interface Row {
-  x: Vec;
-  g: number; // gradient
-  h: number; // hessian
-  w: number;
-}
-
-function leafValue(rows: readonly Row[], lambda: number): number {
-  let g = 0;
-  let h = 0;
-  for (const r of rows) {
-    g += r.w * r.g;
-    h += r.w * r.h;
-  }
-  return -g / (h + lambda);
-}
-
-/** XGBoost-style structure score G²/(H+λ) of a node. */
-function gain(g: number, h: number, lambda: number): number {
-  return (g * g) / (h + lambda);
-}
-
-function buildTree(rows: Row[], depth: number, opts: Required<Omit<GbmOptions, "objective" | "trees" | "learningRate">>): RTree {
-  if (depth >= opts.maxDepth || rows.length < 2) return { value: leafValue(rows, opts.lambda) };
-  let G = 0;
-  let H = 0;
-  let W = 0;
-  for (const r of rows) {
-    G += r.w * r.g;
-    H += r.w * r.h;
-    W += r.w;
-  }
-  const parent = gain(G, H, opts.lambda);
-  let best: { feature: number; split: number; score: number } | null = null;
-  const d = rows[0]!.x.length;
-  for (let f = 0; f < d; f++) {
-    const sorted = [...rows].sort((a, b) => a.x[f]! - b.x[f]!);
-    let gl = 0;
-    let hl = 0;
-    let wl = 0;
-    for (let i = 0; i < sorted.length - 1; i++) {
-      const r = sorted[i]!;
-      gl += r.w * r.g;
-      hl += r.w * r.h;
-      wl += r.w;
-      const a = r.x[f]!;
-      const b = sorted[i + 1]!.x[f]!;
-      if (a === b) continue;
-      if (wl < opts.minLeafWeight || W - wl < opts.minLeafWeight) continue;
-      const score = gain(gl, hl, opts.lambda) + gain(G - gl, H - hl, opts.lambda) - parent;
-      if (score > 1e-12 && (!best || score > best.score)) best = { feature: f, split: (a + b) / 2, score };
-    }
-  }
-  if (!best) return { value: leafValue(rows, opts.lambda) };
-  const left = rows.filter((r) => r.x[best!.feature]! < best!.split);
-  const right = rows.filter((r) => r.x[best!.feature]! >= best!.split);
-  return { feature: best.feature, split: best.split, left: buildTree(left, depth + 1, opts), right: buildTree(right, depth + 1, opts) };
-}
-
-function treeValue(t: RTree, x: Vec): number {
-  while (!("value" in t)) t = x[t.feature]! < t.split ? t.left : t.right;
-  return t.value;
-}
-
-export class GbmModel implements MlPredictor {
-  constructor(
-    readonly objective: GbmObjective,
-    readonly base: number,
-    readonly trees: readonly RTree[],
-    readonly learningRate: number,
-  ) {}
-
-  /** The raw additive score (log-odds for `binary`). */
-  margin(x: Vec): number {
-    let s = this.base;
-    for (const t of this.trees) s += this.learningRate * treeValue(t, x);
-    return s;
-  }
-
-  predict(x: Float32Array): MlPrediction {
-    const m = this.margin(x);
-    if (this.objective === "regression") return { scores: [m], confidence: 1 };
-    const p = sigmoid(m);
-    return { scores: [1 - p, p], confidence: Math.max(p, 1 - p) };
-  }
-}
-
-export function fitGbm(samples: readonly MlSample[], opts: GbmOptions = {}): GbmModel {
-  featureDim(samples.map((s) => s.x));
-  const objective = opts.objective ?? "binary";
-  const lr = opts.learningRate ?? 0.3;
-  const treeOpts = { maxDepth: opts.maxDepth ?? 2, minLeafWeight: opts.minLeafWeight ?? 1, lambda: opts.lambda ?? 1 };
-
-  let wSum = 0;
-  let ySum = 0;
-  for (const s of samples) {
-    wSum += s.weight ?? 1;
-    ySum += (s.weight ?? 1) * s.y;
-  }
-  const yMean = ySum / wSum;
-  const base = objective === "binary" ? Math.log(Math.max(yMean, 1e-6) / Math.max(1 - yMean, 1e-6)) : yMean;
-  const margins = samples.map(() => base);
-  const trees: RTree[] = [];
-  for (let t = 0; t < (opts.trees ?? 50); t++) {
-    const rows: Row[] = samples.map((s, i) => {
-      if (objective === "binary") {
-        const p = sigmoid(margins[i]!);
-        return { x: s.x, g: p - s.y, h: Math.max(p * (1 - p), 1e-6), w: s.weight ?? 1 };
-      }
-      return { x: s.x, g: margins[i]! - s.y, h: 1, w: s.weight ?? 1 };
-    });
-    const tree = buildTree(rows, 0, treeOpts);
-    trees.push(tree);
-    samples.forEach((s, i) => (margins[i] = margins[i]! + lr * treeValue(tree, s.x)));
-  }
-  return new GbmModel(objective, base, trees, lr);
-}
+/**
+ * ml/classical/gbm.ts — a small gradient-boosted tree ensemble.
+ *
+ * Depth-limited regression trees fitted to the loss gradient, one after another,
+ * shrunk by a learning rate. Objectives: `binary` (log-loss, Newton leaf values)
+ * and `regression` (squared error). Exhaustive split search over midpoints —
+ * fine for the catalog's small numeric feature sets, not for wide embeddings.
+ */
+import type { MlPrediction, MlPredictor, MlSample } from "../types.js";
+import { featureDim, sigmoid, type Vec } from "./math.js";
+
+export type GbmObjective = "binary" | "regression";
+
+export interface GbmOptions {
+  objective?: GbmObjective;
+  trees?: number;
+  maxDepth?: number;
+  learningRate?: number;
+  /** Minimum summed sample weight in a leaf. Default 1. */
+  minLeafWeight?: number;
+  /** L2 on leaf values (Newton denominator). Default 1. */
+  lambda?: number;
+}
+
+type RTree = { value: number } | { feature: number; split: number; left: RTree; right: RTree };
+
+interface Row {
+  x: Vec;
+  g: number; // gradient
+  h: number; // hessian
+  w: number;
+}
+
+function leafValue(rows: readonly Row[], lambda: number): number {
+  let g = 0;
+  let h = 0;
+  for (const r of rows) {
+    g += r.w * r.g;
+    h += r.w * r.h;
+  }
+  return -g / (h + lambda);
+}
+
+/** XGBoost-style structure score G²/(H+λ) of a node. */
+function gain(g: number, h: number, lambda: number): number {
+  return (g * g) / (h + lambda);
+}
+
+function buildTree(rows: Row[], depth: number, opts: Required<Omit<GbmOptions, "objective" | "trees" | "learningRate">>): RTree {
+  if (depth >= opts.maxDepth || rows.length < 2) return { value: leafValue(rows, opts.lambda) };
+  let G = 0;
+  let H = 0;
+  let W = 0;
+  for (const r of rows) {
+    G += r.w * r.g;
+    H += r.w * r.h;
+    W += r.w;
+  }
+  const parent = gain(G, H, opts.lambda);
+  let best: { feature: number; split: number; score: number } | null = null;
+  const d = rows[0]!.x.length;
+  for (let f = 0; f < d; f++) {
+    const sorted = [...rows].sort((a, b) => a.x[f]! - b.x[f]!);
+    let gl = 0;
+    let hl = 0;
+    let wl = 0;
+    for (let i = 0; i < sorted.length - 1; i++) {
+      const r = sorted[i]!;
+      gl += r.w * r.g;
+      hl += r.w * r.h;
+      wl += r.w;
+      const a = r.x[f]!;
+      const b = sorted[i + 1]!.x[f]!;
+      if (a === b) continue;
+      if (wl < opts.minLeafWeight || W - wl < opts.minLeafWeight) continue;
+      const score = gain(gl, hl, opts.lambda) + gain(G - gl, H - hl, opts.lambda) - parent;
+      if (score > 1e-12 && (!best || score > best.score)) best = { feature: f, split: (a + b) / 2, score };
+    }
+  }
+  if (!best) return { value: leafValue(rows, opts.lambda) };
+  const left = rows.filter((r) => r.x[best!.feature]! < best!.split);
+  const right = rows.filter((r) => r.x[best!.feature]! >= best!.split);
+  return { feature: best.feature, split: best.split, left: buildTree(left, depth + 1, opts), right: buildTree(right, depth + 1, opts) };
+}
+
+function treeValue(t: RTree, x: Vec): number {
+  while (!("value" in t)) t = x[t.feature]! < t.split ? t.left : t.right;
+  return t.value;
+}
+
+export class GbmModel implements MlPredictor {
+  constructor(
+    readonly objective: GbmObjective,
+    readonly base: number,
+    readonly trees: readonly RTree[],
+    readonly learningRate: number,
+  ) {}
+
+  /** The raw additive score (log-odds for `binary`). */
+  margin(x: Vec): number {
+    let s = this.base;
+    for (const t of this.trees) s += this.learningRate * treeValue(t, x);
+    return s;
+  }
+
+  predict(x: Float32Array): MlPrediction {
+    const m = this.margin(x);
+    if (this.objective === "regression") return { scores: [m], confidence: 1 };
+    const p = sigmoid(m);
+    return { scores: [1 - p, p], confidence: Math.max(p, 1 - p) };
+  }
+}
+
+export function fitGbm(samples: readonly MlSample[], opts: GbmOptions = {}): GbmModel {
+  featureDim(samples.map((s) => s.x));
+  const objective = opts.objective ?? "binary";
+  const lr = opts.learningRate ?? 0.3;
+  const treeOpts = { maxDepth: opts.maxDepth ?? 2, minLeafWeight: opts.minLeafWeight ?? 1, lambda: opts.lambda ?? 1 };
+
+  let wSum = 0;
+  let ySum = 0;
+  for (const s of samples) {
+    wSum += s.weight ?? 1;
+    ySum += (s.weight ?? 1) * s.y;
+  }
+  // All-zero weights would make this 0/0: fall back to the unweighted mean.
+  const yMean = wSum > 0 ? ySum / wSum : samples.reduce((a, s) => a + s.y, 0) / samples.length;
+  const base = objective === "binary" ? Math.log(Math.max(yMean, 1e-6) / Math.max(1 - yMean, 1e-6)) : yMean;
+  const margins = samples.map(() => base);
+  const trees: RTree[] = [];
+  for (let t = 0; t < (opts.trees ?? 50); t++) {
+    const rows: Row[] = samples.map((s, i) => {
+      if (objective === "binary") {
+        const p = sigmoid(margins[i]!);
+        return { x: s.x, g: p - s.y, h: Math.max(p * (1 - p), 1e-6), w: s.weight ?? 1 };
+      }
+      return { x: s.x, g: margins[i]! - s.y, h: 1, w: s.weight ?? 1 };
+    });
+    const tree = buildTree(rows, 0, treeOpts);
+    trees.push(tree);
+    samples.forEach((s, i) => (margins[i] = margins[i]! + lr * treeValue(tree, s.x)));
+  }
+  return new GbmModel(objective, base, trees, lr);
+}

package/src/ml/classical/index.ts

@@ -10,6 +10,7 @@ import { fitLinear, type LinearOptions } from "./linear.js";
 import { fitKMeans, type KMeansOptions } from "./kmeans.js";
 import { fitRobustZ, type RobustZOptions } from "./robust_z.js";
 import { fitEwma, type EwmaOptions } from "./ewma.js";
+import { fitAnomalyComposite, type AnomalyCompositeOptions } from "./anomaly_composite.js";
 import { fitIsolationForest, type IsolationForestOptions } from "./isolation_forest.js";
 import { fitGbm, type GbmOptions } from "./gbm.js";
 
@@ -27,6 +28,8 @@ export { RobustZModel, fitRobustZ, anomalyConfidence } from "./robust_z.js";
 export type { RobustZOptions } from "./robust_z.js";
 export { EwmaModel, fitEwma } from "./ewma.js";
 export type { EwmaOptions } from "./ewma.js";
+export { AnomalyCompositeModel, fitAnomalyComposite } from "./anomaly_composite.js";
+export type { AnomalyCompositeOptions } from "./anomaly_composite.js";
 export { IsolationForestModel, fitIsolationForest } from "./isolation_forest.js";
 export type { IsolationForestOptions } from "./isolation_forest.js";
 export { GbmModel, fitGbm } from "./gbm.js";
@@ -42,6 +45,7 @@ export interface ClassicalOptions {
   kmeans?: KMeansOptions;
   "robust-z"?: RobustZOptions;
   ewma?: EwmaOptions;
+  "anomaly-composite"?: AnomalyCompositeOptions;
   "isolation-forest"?: IsolationForestOptions;
   "gbm-small"?: GbmOptions;
 }
@@ -68,6 +72,8 @@ export function fitClassical(
       return fitRobustZ(samples, opts["robust-z"]);
     case "ewma":
       return fitEwma(samples, opts.ewma);
+    case "anomaly-composite":
+      return fitAnomalyComposite(samples, opts["anomaly-composite"]);
     case "isolation-forest":
       return fitIsolationForest(samples, opts["isolation-forest"]);
     case "gbm-small":