{"version":3,"sources":["../../src/core/geometry/vector.ts","../../src/core/geometry/grassmannian.ts","../../src/advanced/grassmannian-middleware.ts","../../src/core/geometry/manifold.ts","../../src/core/kinematics/engine.ts","../../src/core/kinematics/pid.ts","../../src/advanced/kinematics-middleware.ts","../../src/advanced/manifold-middleware.ts"],"names":["Matrix","SingularValueDecomposition","EigenvalueDecomposition","snapshot","buildDegenerateSnapshot"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Euclidean vector operations for semantic embedding spaces.\n *\n * This module provides the foundational vector math used by CyberLoop's\n * control layers. It operates on arbitrary-dimensional vectors typed as\n * `VectorN`.\n *\n * **v2.1:** Used by PhysicsEngine (EKF) and PIDController.\n * **v3.0:** Will be extended by `manifold.ts` (PCA, curvature, tangent plane).\n * **v4.0:** Will be extended by `grassmannian.ts` (SVD, principal angles, geodesic).\n *\n * @module geometry/vector\n */\n\nimport { Matrix } from 'ml-matrix';\n\nimport type { VectorN } from '../kinematics/types';\n\n// Convert array to Matrix (column vector)\nexport const toMatrix = (v: VectorN): Matrix => {\n return new Matrix([v]).transpose();\n};\n\n// Convert Matrix to array\nexport const toVector = (m: Matrix): VectorN => {\n return m.to1DArray();\n};\n\nexport const add = (v1: VectorN, v2: VectorN): VectorN => {\n const m1 = toMatrix(v1);\n const m2 = toMatrix(v2);\n return toVector(Matrix.add(m1, m2));\n};\n\nexport const subtract = (v1: VectorN, v2: VectorN): VectorN => {\n const m1 = toMatrix(v1);\n const m2 = toMatrix(v2);\n return toVector(Matrix.sub(m1, m2));\n};\n\nexport const scale = (v: VectorN, scalar: number): VectorN => {\n const m = toMatrix(v);\n return toVector(Matrix.mul(m, scalar));\n};\n\nexport const dot = (v1: VectorN, v2: VectorN): number => {\n const m1 = toMatrix(v1);\n const m2 = toMatrix(v2);\n // Dot product is v1^T * v2\n return m1.transpose().mmul(m2).get(0, 0);\n};\n\nexport const norm = (v: VectorN): number => {\n const m = toMatrix(v);\n return m.norm('frobenius'); // Euclidean norm\n};\n\nexport const normalize = (v: VectorN): VectorN => {\n const n = norm(v);\n if (n === 0) return v.map(() => 0);\n return scale(v, 1 / n);\n};\n\n// Projection of a onto b: proj_b(a) = (a . b / |b|^2) * b\nexport const project = (a: VectorN, b: VectorN): VectorN => {\n const bNormSq = dot(b, b);\n if (bNormSq === 0) return b.map(() => 0);\n const scalar = dot(a, b) / bNormSq;\n return scale(b, scalar);\n};\n\n// Rejection of a from b: a - proj_b(a)\nexport const reject = (a: VectorN, b: VectorN): VectorN => {\n const proj = project(a, b);\n return subtract(a, proj);\n};\n\nexport const cosineSimilarity = (v1: VectorN, v2: VectorN): number => {\n const n1 = norm(v1);\n const n2 = norm(v2);\n if (n1 === 0 || n2 === 0) return 0;\n return dot(v1, v2) / (n1 * n2);\n};\n\nexport const angleBetween = (v1: VectorN, v2: VectorN): number => {\n const cos = Math.max(-1, Math.min(1, cosineSimilarity(v1, v2)));\n return Math.acos(cos);\n};\n","/**\n * Grassmannian manifold operations for CyberLoop v4.0.\n *\n * This module provides the math for tracking and comparing **subspaces**\n * on the Grassmannian manifold Gr(k, d) — the space of all k-dimensional\n * subspaces of ℝ^d.\n *\n * A \"subspace\" is represented as an orthonormal basis matrix (d × k),\n * stored column-major as `VectorN[]` where each vector is a basis column.\n * This is the same convention used by `localPCA` in `manifold.ts`.\n *\n * **Key operations:**\n * - `extractSubspace` — SVD on a window of vectors → orthonormal basis\n * - `principalAngles` — canonical angles between two subspaces\n * - `geodesicDistance` — Riemannian distance on Gr(k, d)\n * - `logMap` — tangent vector pointing from one subspace toward another\n * - `incrementalSubspaceUpdate` — O(d·k) rank-1 update (avoids full SVD)\n * - `subspaceProjectionError` — how much of a vector lies outside a subspace\n *\n * @module geometry/grassmannian\n */\n\nimport { Matrix, SingularValueDecomposition } from 'ml-matrix';\n\nimport type { VectorN } from '../kinematics/types';\nimport { norm, scale, subtract } from './vector';\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\n/**\n * An orthonormal basis representing a point on the Grassmannian Gr(k, d).\n *\n * Each element is a d-dimensional column vector. The array has k elements,\n * so the subspace is k-dimensional within ℝ^d.\n */\nexport type SubspaceBasis = VectorN[];\n\n/**\n * Result of extracting a subspace from a window of vectors.\n */\nexport interface SubspaceExtraction {\n /** Orthonormal basis vectors (top-k left singular vectors). */\n basis: SubspaceBasis;\n /** Singular values (descending order). */\n singularValues: number[];\n /** Explained variance ratio of the top-k components (0–1). */\n explainedVariance: number;\n /** Dimension of the ambient space (d). */\n ambientDim: number;\n /** Dimension of the subspace (k). */\n subspaceDim: number;\n}\n\n/**\n * Result of comparing two subspaces on the Grassmannian.\n */\nexport interface SubspaceComparison {\n /** Principal angles between the two subspaces (in radians, ascending). */\n principalAngles: number[];\n /** Geodesic distance on Gr(k, d): sqrt(Σ θ_i²). */\n geodesicDistance: number;\n /** Mean principal angle (average structural alignment). */\n meanAngle: number;\n /** Maximum principal angle (worst-case dimensional divergence). */\n maxAngle: number;\n}\n\n// ─── Core Functions ──────────────────────────────────────────────────────────\n\n/**\n * Extract a subspace from a window of embedding vectors via SVD.\n *\n * Given m vectors of dimension d, computes the top-k left singular vectors\n * of the centered data matrix. These form an orthonormal basis for the\n * k-dimensional subspace that best captures the variance in the window.\n *\n * @param window - Array of m embedding vectors (each dimension d). Must have m ≥ 2.\n * @param k - Number of principal components to extract. If omitted, auto-selects\n * to explain ≥ 80% of variance.\n * @returns Subspace extraction result, or null if the window is degenerate.\n */\nexport function extractSubspace(window: VectorN[], k?: number): SubspaceExtraction | null {\n const m = window.length;\n if (m < 2) return null;\n\n const d = window[0].length;\n if (d === 0) return null;\n\n // 1. Center the data (subtract mean)\n const mean = new Array(d).fill(0);\n for (const v of window) {\n for (let i = 0; i < d; i++) {\n mean[i] += v[i];\n }\n }\n for (let i = 0; i < d; i++) {\n mean[i] /= m;\n }\n\n const centered = window.map((v) => v.map((val, i) => val - mean[i]));\n\n // 2. Build data matrix X (m × d) and compute SVD\n // SVD gives X = U Σ V^T where V columns are the principal directions in ℝ^d\n const X = new Matrix(centered);\n const svd = new SingularValueDecomposition(X);\n\n const singularValues = svd.diagonal; // descending order\n const V = svd.rightSingularVectors; // d × min(m,d), columns are right singular vectors\n\n // 3. Determine effective k\n const totalVariance = singularValues.reduce((s, v) => s + v * v, 0);\n let effectiveK: number;\n\n if (k != null) {\n effectiveK = Math.min(k, singularValues.length, V.columns);\n } else {\n // Auto-select: explain ≥ 80% of variance\n effectiveK = autoSelectK(singularValues, 0.8);\n }\n\n // Ensure at least 1 component\n effectiveK = Math.max(1, effectiveK);\n\n // 4. Extract top-k right singular vectors as basis\n const basis: SubspaceBasis = [];\n for (let j = 0; j < effectiveK; j++) {\n if (j >= V.columns) break;\n const col = V.getColumn(j);\n // Verify it's unit-length (should be from SVD, but normalize for safety)\n const n = norm(col);\n if (n < 1e-12) break; // degenerate\n basis.push(n > 0.999 && n < 1.001 ? col : scale(col, 1 / n));\n }\n\n if (basis.length === 0) return null;\n\n // 5. Compute explained variance\n const topVariance = singularValues\n .slice(0, basis.length)\n .reduce((s, v) => s + v * v, 0);\n const explainedVariance = totalVariance > 0 ? topVariance / totalVariance : 0;\n\n return {\n basis,\n singularValues,\n explainedVariance,\n ambientDim: d,\n subspaceDim: basis.length,\n };\n}\n\n/**\n * Compute the principal angles between two subspaces.\n *\n * Given orthonormal bases U_a (d × k_a) and U_b (d × k_b), computes the\n * canonical angles θ_i via SVD of U_a^T U_b.\n *\n * The principal angles are in [0, π/2] and returned in ascending order.\n * - θ ≈ 0: the corresponding dimensions are aligned\n * - θ ≈ π/2: the corresponding dimensions are orthogonal\n *\n * @param basisA - First subspace basis (array of orthonormal vectors)\n * @param basisB - Second subspace basis (array of orthonormal vectors)\n * @returns Array of principal angles in radians (ascending), length = min(k_a, k_b)\n */\nexport function principalAngles(basisA: SubspaceBasis, basisB: SubspaceBasis): number[] {\n if (basisA.length === 0 || basisB.length === 0) return [];\n\n const d = basisA[0].length;\n\n // Build matrices: U_a is d × k_a, U_b is d × k_b\n const Ua = basisToMatrix(basisA, d);\n const Ub = basisToMatrix(basisB, d);\n\n // M = U_a^T * U_b (k_a × k_b)\n const M = Ua.transpose().mmul(Ub);\n\n // SVD of M: singular values σ_i = cos(θ_i)\n const svd = new SingularValueDecomposition(M);\n const sigmas = svd.diagonal;\n\n // The number of principal angles is min(k_a, k_b).\n // ml-matrix may return more singular values; truncate.\n const numAngles = Math.min(basisA.length, basisB.length);\n const truncated = sigmas.slice(0, numAngles);\n\n // Convert to angles: θ_i = arccos(clamp(σ_i, 0, 1))\n const angles = truncated.map((sigma) => Math.acos(Math.min(1, Math.max(0, sigma))));\n\n // Sort ascending (smallest angle = most aligned dimension)\n angles.sort((a, b) => a - b);\n\n return angles;\n}\n\n/**\n * Compute the geodesic distance between two subspaces on the Grassmannian.\n *\n * d_Gr(U_a, U_b) = sqrt(Σ θ_i²)\n *\n * where θ_i are the principal angles.\n *\n * - d_Gr ≈ 0: Perfect structural alignment\n * - d_Gr ≈ (π/2)·sqrt(k): Maximum divergence (all dimensions orthogonal)\n *\n * @param basisA - First subspace basis\n * @param basisB - Second subspace basis\n * @returns Geodesic distance (non-negative scalar)\n */\nexport function geodesicDistance(basisA: SubspaceBasis, basisB: SubspaceBasis): number {\n const angles = principalAngles(basisA, basisB);\n if (angles.length === 0) return 0;\n return Math.sqrt(angles.reduce((sum, theta) => sum + theta * theta, 0));\n}\n\n/**\n * Compare two subspaces, returning principal angles, geodesic distance,\n * and summary statistics.\n *\n * This is the primary comparison function for the middleware layer.\n *\n * @param basisA - Current subspace basis\n * @param basisB - Reference subspace basis\n * @returns Full comparison result\n */\nexport function compareSubspaces(\n basisA: SubspaceBasis,\n basisB: SubspaceBasis,\n): SubspaceComparison {\n const angles = principalAngles(basisA, basisB);\n\n if (angles.length === 0) {\n return {\n principalAngles: [],\n geodesicDistance: 0,\n meanAngle: 0,\n maxAngle: 0,\n };\n }\n\n const gDist = Math.sqrt(angles.reduce((sum, theta) => sum + theta * theta, 0));\n const meanAngle = angles.reduce((sum, theta) => sum + theta, 0) / angles.length;\n const maxAngle = angles[angles.length - 1]; // already sorted ascending\n\n return {\n principalAngles: angles,\n geodesicDistance: gDist,\n meanAngle,\n maxAngle,\n };\n}\n\n/**\n * Compute the logarithmic map from U_curr to U_target on the Grassmannian.\n *\n * The log map gives a tangent vector (matrix) at U_curr that points toward\n * U_target. This represents the \"direction\" to rotate the current subspace\n * to align with the target.\n *\n * Δ = U_target - U_curr * (U_curr^T * U_target)\n *\n * The result is a d × k matrix in the tangent space at U_curr.\n * Its Frobenius norm equals the geodesic distance (for small distances).\n *\n * @param basisCurr - Current subspace basis\n * @param basisTarget - Target subspace basis\n * @returns Tangent vector as an array of d-dimensional vectors (one per basis direction)\n */\nexport function logMap(basisCurr: SubspaceBasis, basisTarget: SubspaceBasis): VectorN[] {\n if (basisCurr.length === 0 || basisTarget.length === 0) return [];\n\n const d = basisCurr[0].length;\n const k = Math.min(basisCurr.length, basisTarget.length);\n\n // Use only the first k vectors from each basis for compatible dimensions\n const Uc = basisToMatrix(basisCurr.slice(0, k), d);\n const Ut = basisToMatrix(basisTarget.slice(0, k), d);\n\n // Δ = U_target - U_curr * (U_curr^T * U_target)\n // This is the component of U_target that is orthogonal to U_curr\n const projection = Uc.mmul(Uc.transpose().mmul(Ut)); // d × k\n const delta = Matrix.sub(Ut, projection); // d × k\n\n // Convert back to array of vectors\n const result: VectorN[] = [];\n for (let j = 0; j < delta.columns; j++) {\n result.push(delta.getColumn(j));\n }\n return result;\n}\n\n/**\n * Incrementally update a subspace basis when a new vector arrives.\n *\n * This avoids full SVD recomputation by performing a rank-1 update:\n * 1. Project the new vector onto the current subspace\n * 2. Compute the residue (novelty outside the subspace)\n * 3. If the residue is significant, rotate the basis toward it\n *\n * Complexity: O(d·k) per update vs O(d·m²) for full SVD.\n *\n * @param basis - Current orthonormal basis (will not be mutated)\n * @param newVector - New embedding vector to incorporate\n * @param forgetFactor - How much to rotate toward novelty (0 = ignore, 1 = fully absorb).\n * Default: 0.1 (gentle adaptation). This is analogous to a\n * learning rate in Oja's rule.\n * @param noveltyThreshold - Minimum residue norm to trigger rotation. Default: 1e-6.\n * @returns Updated orthonormal basis (same dimensionality as input)\n */\nexport function incrementalSubspaceUpdate(\n basis: SubspaceBasis,\n newVector: VectorN,\n forgetFactor = 0.1,\n noveltyThreshold = 1e-6,\n): SubspaceBasis {\n if (basis.length === 0) return basis;\n\n const d = newVector.length;\n const k = basis.length;\n\n // 1. Project: w = U^T * y_new (how much is explained)\n const coefficients: number[] = [];\n for (let j = 0; j < k; j++) {\n let dotProduct = 0;\n for (let i = 0; i < d; i++) {\n dotProduct += basis[j][i] * newVector[i];\n }\n coefficients.push(dotProduct);\n }\n\n // 2. Reconstruct projection: U * w\n const projected = new Array(d).fill(0);\n for (let j = 0; j < k; j++) {\n for (let i = 0; i < d; i++) {\n projected[i] += coefficients[j] * basis[j][i];\n }\n }\n\n // 3. Residue: r = y_new - U * w (novelty)\n const residue = subtract(newVector, projected);\n const residueNorm = norm(residue);\n\n // If residue is negligible, the new vector is already well-explained\n if (residueNorm < noveltyThreshold) {\n return basis.map((v) => [...v]); // return a copy\n }\n\n // 4. Normalize residue to get the novelty direction\n const noveltyDir = scale(residue, 1 / residueNorm);\n\n // 5. Rotate each basis vector slightly toward the novelty direction\n // using a simplified Oja-like update:\n // u_j' = normalize(u_j + α * (u_j^T * y_new) * noveltyDir)\n //\n // The forget factor α controls how quickly the subspace adapts.\n // We only rotate the basis vector with the smallest eigenvalue\n // contribution (last one) to maintain stability.\n const updatedBasis: SubspaceBasis = basis.map((v) => [...v]);\n\n // Rotate the last basis vector (weakest direction) toward novelty\n const lastIdx = k - 1;\n const lastVec = updatedBasis[lastIdx];\n for (let i = 0; i < d; i++) {\n lastVec[i] = lastVec[i] * (1 - forgetFactor) + noveltyDir[i] * forgetFactor;\n }\n\n // Re-orthonormalize via modified Gram-Schmidt\n for (let j = 0; j < k; j++) {\n // Subtract projections onto all previous basis vectors\n for (let p = 0; p < j; p++) {\n let dot = 0;\n for (let i = 0; i < d; i++) {\n dot += updatedBasis[j][i] * updatedBasis[p][i];\n }\n for (let i = 0; i < d; i++) {\n updatedBasis[j][i] -= dot * updatedBasis[p][i];\n }\n }\n // Normalize\n const n = norm(updatedBasis[j]);\n if (n < 1e-12) {\n // Degenerate: replace with novelty direction\n updatedBasis[j] = [...noveltyDir];\n } else {\n for (let i = 0; i < d; i++) {\n updatedBasis[j][i] /= n;\n }\n }\n }\n\n return updatedBasis;\n}\n\n/**\n * Compute how much of a vector lies outside a subspace.\n *\n * This is the norm of the rejection (component orthogonal to the subspace).\n * Useful for detecting when new data introduces dimensions not captured\n * by the current subspace.\n *\n * @param vector - The vector to test\n * @param basis - Orthonormal subspace basis\n * @returns Norm of the component outside the subspace (0 = fully explained)\n */\nexport function subspaceProjectionError(vector: VectorN, basis: SubspaceBasis): number {\n if (basis.length === 0) return norm(vector);\n\n const d = vector.length;\n\n // Project onto subspace\n const projected = new Array(d).fill(0);\n for (const u of basis) {\n let coeff = 0;\n for (let i = 0; i < d; i++) {\n coeff += vector[i] * u[i];\n }\n for (let i = 0; i < d; i++) {\n projected[i] += coeff * u[i];\n }\n }\n\n // Residue norm\n return norm(subtract(vector, projected));\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\n/**\n * Auto-select the number of components to explain at least `threshold`\n * fraction of total variance, based on singular values.\n *\n * @param singularValues - Singular values in descending order\n * @param threshold - Explained variance threshold (default 0.8)\n * @returns Number of components needed\n */\nfunction autoSelectK(singularValues: number[], threshold = 0.8): number {\n const totalVariance = singularValues.reduce((s, v) => s + v * v, 0);\n if (totalVariance <= 0) return singularValues.length;\n\n let cumulative = 0;\n for (let i = 0; i < singularValues.length; i++) {\n cumulative += singularValues[i] * singularValues[i];\n if (cumulative / totalVariance >= threshold) return i + 1;\n }\n return singularValues.length;\n}\n\n/**\n * Convert a SubspaceBasis (array of column vectors) to a Matrix (d × k).\n */\nfunction basisToMatrix(basis: SubspaceBasis, d: number): Matrix {\n const k = basis.length;\n const data = new Array(d);\n for (let i = 0; i < d; i++) {\n data[i] = new Array(k);\n for (let j = 0; j < k; j++) {\n data[i][j] = basis[j][i]; // transpose: basis[j] is column j\n }\n }\n return new Matrix(data);\n}\n","import { compareSubspaces, extractSubspace, logMap } from '../core/geometry/grassmannian';\nimport type { Logger } from '../core/interfaces';\nimport type { GrassmannianSnapshot, StateEmbedder, SubspaceTrajectory } from '../core/kinematics/interfaces';\nimport type { VectorN } from '../core/kinematics/types';\nimport type { Middleware, StepContext, StepResult } from '../core/middleware/types';\n\nexport interface GrassmannianMiddlewareOpts {\n /** Embedder to convert state → vector. Same as kinematicsMiddleware. */\n embedder: StateEmbedder;\n /**\n * Number of recent embeddings to keep in the sliding window.\n * The subspace is extracted from this window each step.\n * Larger windows = more stable subspace, slower to react.\n * Smaller windows = more responsive, noisier.\n * Default: 10.\n */\n windowSize?: number;\n /**\n * Number of principal components (subspace dimension k).\n * If omitted, auto-selects to explain ≥ 80% of variance.\n */\n subspaceDim?: number;\n /**\n * Optional reference trajectory for comparison.\n * If provided, the middleware compares the current subspace to\n * `trajectory.referenceAt(ctx.step)` each step and computes\n * geodesic distance, principal angles, and steering direction.\n *\n * If omitted, the middleware only extracts and reports the current\n * subspace (no comparison, no drift detection).\n */\n trajectory?: SubspaceTrajectory;\n /**\n * Geodesic distance threshold for drift detection.\n * When the distance to the reference subspace exceeds this value,\n * `isDrifting` is set to true.\n *\n * Only meaningful when `trajectory` is provided.\n * If omitted, drift detection is disabled (isDrifting always false).\n */\n driftThreshold?: number;\n /**\n * Action to take when drift is detected.\n * - `'warn'` — annotate `isDrifting: true` in metadata, do not halt (default)\n * - `'halt'` — return `'halt'` to stop the control loop\n */\n driftAction?: 'warn' | 'halt';\n /**\n * Whether to compute the log map (steering direction) when a reference\n * trajectory is provided. The log map gives the tangent vector pointing\n * from the current subspace toward the reference.\n *\n * Default: true (when trajectory is provided).\n * Set to false to save computation if you only need distance/angles.\n */\n computeSteering?: boolean;\n /** Optional logger for Grassmannian telemetry. */\n logger?: Logger;\n}\n\n/**\n * Advanced middleware that performs Grassmannian subspace tracking each step.\n *\n * It embeds the current state, maintains a sliding window of recent embeddings,\n * extracts a subspace via SVD, and optionally compares it to a reference\n * trajectory on the Grassmannian manifold.\n *\n * Writes `ctx.metadata['grassmannian']` with a `GrassmannianSnapshot` containing:\n * - Current subspace basis and extraction quality\n * - Principal angles and geodesic distance to reference (if trajectory provided)\n * - Steering direction via log map (if enabled)\n * - Drift detection (if threshold configured)\n *\n * **Ordering:** Can be stacked independently of `kinematicsMiddleware` and\n * `manifoldMiddleware`. They observe different things and write to different\n * metadata channels.\n */\nexport function grassmannianMiddleware(opts: GrassmannianMiddlewareOpts): Middleware {\n const windowSize = opts.windowSize ?? 10;\n const driftAction = opts.driftAction ?? 'warn';\n const computeSteering = opts.computeSteering ?? true;\n\n let window: VectorN[] = [];\n\n return {\n name: 'grassmannian',\n\n setup(): Promise {\n window = [];\n return Promise.resolve();\n },\n\n async beforeStep(ctx: StepContext): Promise | 'halt'> {\n const observation = await opts.embedder.embed(ctx.state);\n\n // Maintain sliding window (FIFO)\n window.push(observation);\n if (window.length > windowSize) {\n window = window.slice(window.length - windowSize);\n }\n\n // Need at least 2 vectors to extract a subspace\n if (window.length < 2) {\n return {\n ...ctx,\n metadata: {\n ...ctx.metadata,\n grassmannian: buildDegenerateSnapshot(observation.length),\n },\n };\n }\n\n // Extract subspace from sliding window via SVD\n const extraction = extractSubspace(window, opts.subspaceDim);\n\n if (!extraction || extraction.basis.length === 0) {\n return {\n ...ctx,\n metadata: {\n ...ctx.metadata,\n grassmannian: buildDegenerateSnapshot(observation.length),\n },\n };\n }\n\n // Compare to reference trajectory if provided\n let comparison = {\n principalAngles: [] as number[],\n geodesicDistance: 0,\n meanAngle: 0,\n maxAngle: 0,\n };\n let steering: VectorN[] | null = null;\n let isDrifting = false;\n\n if (opts.trajectory) {\n const referenceBasis = opts.trajectory.referenceAt(ctx.step);\n\n if (referenceBasis.length > 0) {\n comparison = compareSubspaces(extraction.basis, referenceBasis);\n\n // Compute steering direction (log map)\n if (computeSteering) {\n steering = logMap(extraction.basis, referenceBasis);\n }\n\n // Drift detection\n if (opts.driftThreshold != null) {\n isDrifting = comparison.geodesicDistance > opts.driftThreshold;\n }\n }\n }\n\n const snapshot: GrassmannianSnapshot = {\n currentBasis: extraction.basis,\n principalAngles: comparison.principalAngles,\n geodesicDistance: comparison.geodesicDistance,\n meanAngle: comparison.meanAngle,\n maxAngle: comparison.maxAngle,\n explainedVariance: extraction.explainedVariance,\n windowSize: window.length,\n subspaceDim: extraction.subspaceDim,\n isDrifting,\n steeringDirection: steering,\n };\n\n if (opts.logger) {\n opts.logger.info(\n {\n grassmannian: {\n step: ctx.step,\n geodesicDistance: parseFloat(comparison.geodesicDistance.toFixed(4)),\n meanAngle: parseFloat(comparison.meanAngle.toFixed(4)),\n maxAngle: parseFloat(comparison.maxAngle.toFixed(4)),\n explainedVariance: parseFloat(extraction.explainedVariance.toFixed(4)),\n windowSize: window.length,\n subspaceDim: extraction.subspaceDim,\n isDrifting,\n },\n },\n `[Grassmannian] Step ${ctx.step}: d_Gr=${comparison.geodesicDistance.toFixed(4)}, meanθ=${comparison.meanAngle.toFixed(4)}, maxθ=${comparison.maxAngle.toFixed(4)}, k=${extraction.subspaceDim}, Drifting=${isDrifting}`,\n );\n }\n\n // Halt if drift detected and action is 'halt'\n if (isDrifting && driftAction === 'halt') {\n return 'halt';\n }\n\n return {\n ...ctx,\n metadata: { ...ctx.metadata, grassmannian: snapshot },\n };\n },\n\n afterStep(_ctx: StepContext, _result: StepResult): Promise {\n return Promise.resolve();\n },\n };\n}\n\n/**\n * Build a GrassmannianSnapshot for degenerate cases (not enough vectors in window).\n */\nfunction buildDegenerateSnapshot(ambientDim: number): GrassmannianSnapshot {\n return {\n currentBasis: [],\n principalAngles: [],\n geodesicDistance: 0,\n meanAngle: 0,\n maxAngle: 0,\n explainedVariance: 0,\n windowSize: ambientDim > 0 ? 1 : 0,\n subspaceDim: 0,\n isDrifting: false,\n steeringDirection: null,\n };\n}\n","/**\n * Riemannian manifold operations for CyberLoop v3.0.\n *\n * This module approximates the local geometry of a data manifold using\n * Principal Component Analysis on k nearest neighbors. It enables the\n * control layer to distinguish between on-manifold motion (tangent) and\n * off-manifold drift (normal).\n *\n * **Key optimization:** Uses the Gramian dual trick — instead of\n * diagonalizing the d×d covariance matrix (O(d³)), we diagonalize the\n * k×k Gramian matrix (O(k³) where k << d). The non-zero eigenvalues\n * are identical.\n *\n * @module geometry/manifold\n */\n\nimport { EigenvalueDecomposition, Matrix } from 'ml-matrix';\n\nimport type { VectorN } from '../kinematics/types';\nimport { dot, norm, scale, subtract } from './vector';\n\n/**\n * Local geometry at a point on the data manifold.\n */\nexport interface LocalGeometry {\n /** Orthonormal basis spanning the tangent plane (valid directions). */\n tangentBasis: VectorN[];\n /** Orthonormal basis spanning the normal space (drift directions). */\n normalBasis: VectorN[];\n /** Eigenvalues from PCA (descending order). */\n eigenvalues: number[];\n /** Local curvature κ (0 = flat, 1 = maximally curved / isotropic). */\n curvature: number;\n /** Explained variance ratio of the tangent space (0–1). */\n explainedVariance: number;\n /** Mean of the neighborhood (centroid). */\n centroid: VectorN;\n}\n\n/**\n * Compute the centroid (mean) of a set of vectors.\n */\nexport function centroid(vectors: VectorN[]): VectorN {\n const d = vectors[0].length;\n const mean = new Array(d).fill(0);\n for (const v of vectors) {\n for (let i = 0; i < d; i++) {\n mean[i] += v[i];\n }\n }\n const n = vectors.length;\n for (let i = 0; i < d; i++) {\n mean[i] /= n;\n }\n return mean;\n}\n\n/**\n * Compute local curvature from eigenvalues.\n *\n * κ ≈ 1 - (Σ top eigenvalues) / (Σ all eigenvalues)\n *\n * - κ ≈ 0: flat terrain (data lies in a low-dimensional subspace)\n * - κ ≈ 1: isotropic / maximally curved (no dominant directions)\n *\n * @param eigenvalues - Eigenvalues in descending order\n * @param topK - Number of top eigenvalues to consider as \"tangent\"\n */\nexport function curvature(eigenvalues: number[], topK: number): number {\n const total = eigenvalues.reduce((s, v) => s + v, 0);\n if (total <= 0) return 1; // No variance → maximally uncertain\n const topSum = eigenvalues.slice(0, topK).reduce((s, v) => s + v, 0);\n return 1 - topSum / total;\n}\n\n/**\n * Determine the number of principal components that explain at least\n * `threshold` fraction of the total variance.\n *\n * @param eigenvalues - Eigenvalues in descending order\n * @param threshold - Explained variance threshold (default 0.8 = 80%)\n * @returns Number of components needed\n */\nexport function autoTopK(eigenvalues: number[], threshold = 0.8): number {\n const total = eigenvalues.reduce((s, v) => s + v, 0);\n if (total <= 0) return eigenvalues.length;\n let cumulative = 0;\n for (let i = 0; i < eigenvalues.length; i++) {\n cumulative += eigenvalues[i];\n if (cumulative / total >= threshold) return i + 1;\n }\n return eigenvalues.length;\n}\n\n/**\n * Compute the local geometry of a data manifold at a point, given its\n * k nearest neighbors.\n *\n * Uses the **Gramian dual trick**: instead of the d×d covariance matrix\n * C = X^T X, we compute the k×k Gramian G = X X^T. The non-zero\n * eigenvalues of G are identical to those of C, and the eigenvectors\n * of C can be recovered as u_i = X^T v_i / sqrt(λ_i).\n *\n * @param neighbors - k nearest neighbor vectors (each of dimension d)\n * @param topK - Number of principal components for tangent space.\n * If omitted, auto-selects to explain 80% of variance.\n * @returns Local geometry (tangent/normal basis, curvature, etc.)\n */\nexport function localPCA(neighbors: VectorN[], topK?: number): LocalGeometry {\n const k = neighbors.length;\n const d = neighbors[0].length;\n\n // Degenerate case: single point → no geometry computable\n if (k < 2) {\n return {\n tangentBasis: [],\n normalBasis: [],\n eigenvalues: [],\n curvature: 1,\n explainedVariance: 0,\n centroid: neighbors[0] ?? new Array(d).fill(0),\n };\n }\n\n // 1. Center the data (subtract mean)\n const mean = centroid(neighbors);\n const centered: number[][] = neighbors.map((v) =>\n v.map((val, i) => val - mean[i]),\n );\n\n // 2. Build the centered data matrix X (k × d)\n const X = new Matrix(centered);\n\n // 3. Compute Gramian G = X X^T (k × k)\n // PERF: This is O(k²·d) for the multiplication + O(k³) for eigendecomposition.\n // For k ≈ 50 and d ≈ 1536, this is ~4M ops — well within sub-ms on modern CPUs.\n // The real bottleneck is the k-NN query upstream, not this math.\n const G = X.mmul(X.transpose());\n\n // Scale by 1/(k-1) for unbiased covariance estimate\n const scaleFactor = 1 / (k - 1);\n const Gscaled = Matrix.mul(G, scaleFactor);\n\n // 4. Eigendecompose G (symmetric → real eigenvalues)\n const evd = new EigenvalueDecomposition(Gscaled);\n const rawEigenvalues = evd.realEigenvalues;\n const V = evd.eigenvectorMatrix; // k × k, columns are eigenvectors of G\n\n // 5. Sort eigenvalues descending and track indices\n const indexed = rawEigenvalues.map((val, i) => ({ val: Math.max(val, 0), i }));\n indexed.sort((a, b) => b.val - a.val);\n\n const sortedEigenvalues = indexed.map((e) => e.val);\n\n // 6. Determine topK (auto or explicit)\n const effectiveTopK = topK ?? autoTopK(sortedEigenvalues);\n\n // 7. Map eigenvectors of G back to d-dimensional space\n // u_i = X^T v_i / sqrt(λ_i)\n // Then normalize to get orthonormal basis vectors.\n const allBasis: VectorN[] = [];\n for (const entry of indexed) {\n if (entry.val < 1e-12) {\n // Eigenvalue ≈ 0 → this direction has no variance, skip\n break;\n }\n // Extract eigenvector v_i (column of V)\n const vi = V.getColumn(entry.i);\n const viMat = new Matrix([vi]).transpose(); // k × 1\n\n // u_i = X^T * v_i (d × 1)\n const ui = X.transpose().mmul(viMat);\n const uiVec = ui.to1DArray();\n\n // Normalize to unit length\n const uiNorm = norm(uiVec);\n if (uiNorm < 1e-12) continue;\n allBasis.push(scale(uiVec, 1 / uiNorm));\n }\n\n // 8. Split into tangent (top) and normal (rest)\n const tangentBasis = allBasis.slice(0, effectiveTopK);\n const normalBasis = allBasis.slice(effectiveTopK);\n\n // 9. Compute curvature and explained variance\n const kappa = curvature(sortedEigenvalues, effectiveTopK);\n const totalVariance = sortedEigenvalues.reduce((s, v) => s + v, 0);\n const tangentVariance = sortedEigenvalues.slice(0, effectiveTopK).reduce((s, v) => s + v, 0);\n const explainedVar = totalVariance > 0 ? tangentVariance / totalVariance : 0;\n\n return {\n tangentBasis,\n normalBasis,\n eigenvalues: sortedEigenvalues,\n curvature: kappa,\n explainedVariance: explainedVar,\n centroid: mean,\n };\n}\n\n/**\n * Project a vector onto the subspace spanned by the given orthonormal basis.\n *\n * v_projected = Σ (v · u_i) * u_i\n */\nexport function projectOnto(v: VectorN, basis: VectorN[]): VectorN {\n const d = v.length;\n const result = new Array(d).fill(0);\n for (const u of basis) {\n const coeff = dot(v, u);\n for (let i = 0; i < d; i++) {\n result[i] += coeff * u[i];\n }\n }\n return result;\n}\n\n/**\n * Decompose a vector into tangent and normal components relative to a\n * tangent basis.\n *\n * v = v_tangent + v_normal\n *\n * - v_tangent: on-manifold component (projection onto tangent space)\n * - v_normal: off-manifold component (remainder = drift)\n */\nexport function decompose(\n v: VectorN,\n tangentBasis: VectorN[],\n): { tangent: VectorN; normal: VectorN } {\n const tangent = projectOnto(v, tangentBasis);\n const normal = subtract(v, tangent);\n return { tangent, normal };\n}\n\n/**\n * Compute the distance from a point to the manifold centroid.\n */\nexport function distanceToCentroid(point: VectorN, manifoldCentroid: VectorN): number {\n return norm(subtract(point, manifoldCentroid));\n}\n","import type { KinematicsConfig } from './interfaces';\nimport { add, angleBetween, norm, reject, scale, subtract } from './math';\nimport type { KinematicState, VectorN } from './types';\n\nexport class PhysicsEngine {\n constructor(private config: KinematicsConfig) { }\n\n /**\n * Updates the kinematic state based on a new observation.\n * Uses a simplified Kalman Filter (EKF) for state estimation.\n */\n update(\n prev: KinematicState,\n observation: VectorN,\n origin: VectorN\n ): { next: KinematicState; error: VectorN; coherence: number } {\n // 1. Predict (Simple Motion Model: assume constant velocity)\n const s_pred = add(prev.position, prev.velocity);\n\n // 2. Update (Kalman Gain)\n const K = this.config.ProcessNoise / (this.config.ProcessNoise + this.config.MeasureNoise);\n\n // Innovation\n const innovation = subtract(observation, s_pred);\n const s_new = add(s_pred, scale(innovation, K));\n const v_new = subtract(s_new, prev.position);\n\n // 3. Calculate Heading\n // Empirical decision: Use Local Velocity (Instantaneous Momentum) instead of Global Heading.\n // Experiments showed that Global Heading causes \"semantic inertia,\" trapping agents in\n // obsolete contexts (e.g., hardware history vs modern CPU). Local Velocity allows\n // the agent to \"forget the past\" and exploit hub nodes more effectively.\n\n let heading = v_new;\n\n // Fallback: If velocity is near zero (no local movement), use global direction\n // to maintain orientation towards the origin/target context.\n // For t=0, v_new is equivalent to (s_new - origin), so this handles start gracefully.\n if (norm(heading) < 1e-9) {\n heading = subtract(s_new, origin);\n }\n\n const prevHeading = prev.heading;\n\n // --- SAFETY CHECK START ---\n // Check if we have enough previous momentum to define a \"path\".\n // If prevHeading is near zero, we cannot calculate angle or projection.\n const prevHeadingNorm = norm(prevHeading);\n const hasMomentum = prev.stepIndex > 0 && prevHeadingNorm > 1e-9;\n // --- SAFETY CHECK END ---\n\n // 4. Calculate Coherence (Angle change)\n // Protected by hasMomentum to prevent NaN in angleBetween\n const coherence = hasMomentum ? angleBetween(heading, prevHeading) : 0;\n\n // 5. Calculate Cross-track Error (Vector Rejection)\n let error: VectorN;\n\n if (!hasMomentum) {\n // No previous track to follow, so error is zero.\n // We accept the current heading as the new truth.\n error = heading.map(() => 0);\n } else {\n // Safe to reject because prevHeading is non-zero\n error = reject(heading, prevHeading);\n }\n\n const nextState: KinematicState = {\n position: s_new,\n velocity: v_new,\n heading: heading,\n stepIndex: prev.stepIndex + 1,\n };\n\n return { next: nextState, error, coherence };\n }\n}\n","import { add, norm, scale, subtract } from './math';\nimport type { ControlSignal, VectorN } from './types';\n\nexport class PIDController {\n private integral: VectorN;\n private lastError: VectorN | null = null;\n\n constructor(\n private Kp: number,\n private Ki: number,\n private Kd: number,\n private stabilityThreshold = 0.1\n ) {\n this.integral = []; // Initialize empty, will adapt to dimension on first call\n }\n\n compute(error: VectorN, dt = 1): ControlSignal {\n // Initialize integral term if needed\n if (this.integral.length === 0) {\n this.integral = error.map(() => 0);\n }\n\n this.lastError ??= error;\n\n // P Term\n const P = scale(error, this.Kp);\n\n // I Term\n this.integral = add(this.integral, scale(error, dt));\n const I = scale(this.integral, this.Ki);\n\n // D Term\n const derivative = scale(subtract(error, this.lastError), 1 / dt);\n const D = scale(derivative, this.Kd);\n\n // Total Correction: u = P + I + D\n const correction = add(add(P, I), D);\n\n // Update state\n this.lastError = error;\n\n const magnitude = norm(correction);\n\n // In v2.1, \"Stability\" is defined by the controller not fighting the agent.\n // If correction is small, we are stable.\n const isStable = magnitude < this.stabilityThreshold;\n\n return {\n correctionVector: correction,\n magnitude,\n isStable,\n log: `PID(P=${norm(P).toFixed(4)}, I=${norm(I).toFixed(4)}, D=${norm(D).toFixed(4)})`\n };\n }\n\n reset() {\n this.integral = [];\n this.lastError = null;\n }\n}\n","import { decompose, localPCA } from '../core/geometry/manifold';\nimport type { Logger } from '../core/interfaces';\nimport { PhysicsEngine } from '../core/kinematics/engine';\nimport type { ManifoldProvider, StateEmbedder } from '../core/kinematics/interfaces';\nimport { norm } from '../core/kinematics/math';\nimport { PIDController } from '../core/kinematics/pid';\nimport type { KinematicState, VectorN } from '../core/kinematics/types';\nimport type { Middleware, StepContext, StepResult } from '../core/middleware/types';\n\n/**\n * Kinematics data attached to `ctx.metadata['kinematics']` each step.\n */\nexport interface KinematicsSnapshot {\n position: VectorN;\n velocity: VectorN;\n error: VectorN;\n errorMagnitude: number;\n correctionMagnitude: number;\n coherenceAngleDeg: number;\n isStable: boolean;\n stepIndex: number;\n}\n\n/**\n * Correction info attached to `ctx.metadata['kinematicsCorrection']` when drift is detected.\n */\nexport interface CorrectionInfo {\n vector: VectorN;\n magnitude: number;\n log: string;\n}\n\nexport interface KinematicsMiddlewareOpts {\n /** Embedder to convert state → vector. */\n embedder: StateEmbedder;\n /** Goal embedding vector (used as origin for physics). */\n goalEmbedding: number[];\n /** PID controller parameters. */\n pid?: {\n Kp?: number;\n Ki?: number;\n Kd?: number;\n stabilityThreshold?: number;\n };\n /** Physics engine (EKF) parameters. */\n physics?: {\n processNoise?: number;\n measureNoise?: number;\n };\n /**\n * v3.0: Optional corpus geometry provider for manifold-aware control.\n *\n * When provided, the PID controller uses the **normal component** of the\n * EKF velocity (v_normal — off-manifold drift) as its error signal instead\n * of the raw physics error. This means the controller only corrects for\n * drift off the data manifold, not for valid on-manifold exploration.\n *\n * Requires the same `ManifoldProvider` used by `manifoldMiddleware`.\n */\n manifold?: {\n provider: ManifoldProvider;\n /** Number of neighbors for local PCA. Default: 50. */\n k?: number;\n /** Number of principal components for tangent space. Default: auto (80% variance). */\n topK?: number;\n };\n /** Optional logger for kinematics telemetry. */\n logger?: Logger;\n}\n\n/**\n * Advanced middleware that detects semantic drift using an EKF physics engine\n * and PID controller.\n *\n * Each step, it embeds the state into a vector, updates the physics model,\n * and computes a correction signal. Results are stored in `ctx.metadata`:\n *\n * - `metadata['kinematics']` — `KinematicsSnapshot` with position, velocity, error, etc.\n * - `metadata['kinematicsCorrection']` — `CorrectionInfo` (only when drift detected).\n *\n * The middleware **observes and annotates** — it does not halt or override actions.\n * Downstream middleware or the agent can read the correction to decide how to respond.\n */\nexport function kinematicsMiddleware(opts: KinematicsMiddlewareOpts): Middleware {\n const pidOpts = opts.pid ?? {};\n const Kp = pidOpts.Kp ?? 1.0;\n const Ki = pidOpts.Ki ?? 0.0;\n const Kd = pidOpts.Kd ?? 0.0;\n const stabilityThreshold = pidOpts.stabilityThreshold ?? 0.1;\n\n const physicsOpts = opts.physics ?? {};\n const processNoise = physicsOpts.processNoise ?? 0.01;\n const measureNoise = physicsOpts.measureNoise ?? 0.1;\n\n const engine = new PhysicsEngine({ ProcessNoise: processNoise, MeasureNoise: measureNoise, PID: { Kp, Ki, Kd }, MaxDeviation: stabilityThreshold });\n const pid = new PIDController(Kp, Ki, Kd, stabilityThreshold);\n\n let origin: VectorN | null = null;\n let lastPhysicsState: KinematicState | null = null;\n\n return {\n name: 'kinematics',\n\n setup(): Promise {\n origin = opts.goalEmbedding;\n lastPhysicsState = null;\n pid.reset();\n return Promise.resolve();\n },\n\n async beforeStep(ctx: StepContext): Promise> {\n const observation = await opts.embedder.embed(ctx.state);\n\n // First step: initialize physics state, no correction possible\n if (!lastPhysicsState) {\n lastPhysicsState = {\n position: observation,\n velocity: observation.map(() => 0),\n heading: observation.map(() => 0),\n stepIndex: 0,\n };\n\n const snapshot: KinematicsSnapshot = {\n position: observation,\n velocity: observation.map(() => 0),\n error: observation.map(() => 0),\n errorMagnitude: 0,\n correctionMagnitude: 0,\n coherenceAngleDeg: 0,\n isStable: true,\n stepIndex: 0,\n };\n\n return {\n ...ctx,\n metadata: { ...ctx.metadata, kinematics: snapshot },\n };\n }\n\n // Update physics\n const { next, error: rawError, coherence } = engine.update(lastPhysicsState, observation, origin!);\n\n // v3.0: If manifold provider is configured, use v_normal as PID error\n // instead of raw physics error. This makes the controller correct only\n // for off-manifold drift, not valid on-manifold exploration.\n let pidError = rawError;\n if (opts.manifold) {\n // PERF: k-NN query is the bottleneck here, same as in manifoldMiddleware.\n // If both middlewares are stacked, this is a redundant query.\n // Future optimization: share geometry via metadata.\n const manifoldK = opts.manifold.k ?? 50;\n const neighbors = await opts.manifold.provider.knn(observation, manifoldK);\n if (neighbors.length >= 2) {\n const geometry = localPCA(neighbors, opts.manifold.topK);\n if (geometry.tangentBasis.length > 0) {\n const { normal } = decompose(next.velocity, geometry.tangentBasis);\n pidError = normal;\n }\n }\n }\n\n // Compute PID correction\n const correction = pid.compute(pidError);\n\n const angleDeg = coherence * 180 / Math.PI;\n\n const snapshot: KinematicsSnapshot = {\n position: next.position,\n velocity: next.velocity,\n error: pidError,\n errorMagnitude: norm(pidError),\n correctionMagnitude: correction.magnitude,\n coherenceAngleDeg: angleDeg,\n isStable: correction.isStable,\n stepIndex: next.stepIndex,\n };\n\n const metadata: Record = { ...ctx.metadata, kinematics: snapshot };\n\n if (!correction.isStable) {\n const correctionInfo: CorrectionInfo = {\n vector: correction.correctionVector,\n magnitude: correction.magnitude,\n log: correction.log,\n };\n metadata['kinematicsCorrection'] = correctionInfo;\n }\n\n lastPhysicsState = next;\n\n return { ...ctx, metadata };\n },\n\n afterStep(ctx: StepContext, _result: StepResult): Promise {\n if (opts.logger) {\n const snapshot = ctx.metadata['kinematics'] as KinematicsSnapshot | undefined;\n if (snapshot) {\n opts.logger.info(\n {\n kinematics: {\n step: snapshot.stepIndex,\n angle_deg: parseFloat(snapshot.coherenceAngleDeg.toFixed(1)),\n error: parseFloat(snapshot.errorMagnitude.toFixed(4)),\n correction: parseFloat(snapshot.correctionMagnitude.toFixed(4)),\n stable: snapshot.isStable,\n },\n },\n `[Kinematics] Step ${snapshot.stepIndex}: Angle=${snapshot.coherenceAngleDeg.toFixed(1)}°, Err=${snapshot.errorMagnitude.toFixed(4)}, Stable=${snapshot.isStable}`,\n );\n }\n }\n return Promise.resolve();\n },\n };\n}\n","import { decompose, distanceToCentroid, localPCA } from '../core/geometry/manifold';\nimport type { Logger } from '../core/interfaces';\nimport type { ManifoldProvider, ManifoldSnapshot, StateEmbedder } from '../core/kinematics/interfaces';\nimport { norm, subtract } from '../core/kinematics/math';\nimport type { VectorN } from '../core/kinematics/types';\nimport type { Middleware, StepContext, StepResult } from '../core/middleware/types';\nimport type { KinematicsSnapshot } from './kinematics-middleware';\n\nexport interface ManifoldMiddlewareOpts {\n /** Embedder to convert state → vector. */\n embedder: StateEmbedder;\n /** Corpus geometry provider (vector DB, embedding store, etc.). */\n manifold: ManifoldProvider;\n /** Number of neighbors for local PCA. Default: 50. */\n k?: number;\n /**\n * Number of principal components for tangent space.\n * If omitted, auto-selects to explain 80% of variance.\n */\n topK?: number;\n /**\n * Distance threshold for drift detection. When the nearest neighbor\n * distance exceeds this value, the agent is considered to be drifting\n * off the manifold (in a \"data desert\").\n *\n * If omitted, drift detection is disabled (isDrifting always false).\n */\n driftThreshold?: number;\n /**\n * Action to take when drift is detected.\n * - `'warn'` — annotate `isDrifting: true` in metadata, do not halt (default)\n * - `'halt'` — return `'halt'` to stop the control loop\n */\n driftAction?: 'warn' | 'halt';\n /** Optional logger for manifold telemetry. */\n logger?: Logger;\n}\n\n/**\n * Advanced middleware that performs Riemannian manifold analysis each step.\n *\n * It embeds the current state, queries the ManifoldProvider for k nearest\n * neighbors, runs local PCA to compute the tangent/normal decomposition,\n * and annotates `ctx.metadata['manifold']` with a `ManifoldSnapshot`.\n *\n * **Velocity source:** If `kinematicsMiddleware` is stacked before this\n * middleware, the EKF-filtered velocity from `metadata['kinematics']` is\n * used. Otherwise, raw velocity is computed as (current - previous embedding).\n *\n * The middleware **observes and annotates** by default. When `driftThreshold`\n * is set, it can also detect when the agent enters a \"data desert\" (no nearby\n * corpus data). The `driftAction` option controls whether this triggers a\n * halt or just a warning annotation in metadata.\n *\n * **Ordering:** Stack this middleware AFTER `kinematicsMiddleware` so that\n * the filtered velocity is available.\n */\nexport function manifoldMiddleware(opts: ManifoldMiddlewareOpts): Middleware {\n const k = opts.k ?? 50;\n const driftAction = opts.driftAction ?? 'warn';\n\n let previousEmbedding: VectorN | null = null;\n\n return {\n name: 'manifold',\n\n setup(): Promise {\n previousEmbedding = null;\n return Promise.resolve();\n },\n\n async beforeStep(ctx: StepContext): Promise> {\n const observation = await opts.embedder.embed(ctx.state);\n\n // PERF: The k-NN query is likely the dominant cost in this middleware.\n // Future work: add caching if position hasn't moved significantly,\n // or accept a timeout option on ManifoldProvider.\n const neighbors = await opts.manifold.knn(observation, k);\n\n // Degenerate case: not enough neighbors for meaningful PCA\n if (neighbors.length < 2) {\n previousEmbedding = observation;\n return {\n ...ctx,\n metadata: {\n ...ctx.metadata,\n manifold: buildDegenerateSnapshot(observation, neighbors.length),\n },\n };\n }\n\n // Run local PCA (Gramian dual trick — O(k³) not O(d³))\n const geometry = localPCA(neighbors, opts.topK);\n\n // Resolve velocity: prefer EKF-filtered from kinematics middleware\n const velocity = resolveVelocity(ctx, observation, previousEmbedding);\n\n // Decompose velocity into tangent (on-manifold) and normal (drift)\n const { tangent, normal } = geometry.tangentBasis.length > 0\n ? decompose(velocity, geometry.tangentBasis)\n : { tangent: velocity.map(() => 0), normal: velocity };\n\n // Compute distance to nearest neighbor\n const nearestDist = nearestNeighborDistance(observation, neighbors);\n\n // Determine if agent is drifting off manifold\n const isDrifting = opts.driftThreshold != null && nearestDist > opts.driftThreshold;\n\n const snapshot: ManifoldSnapshot = {\n velocityTangent: tangent,\n velocityNormal: normal,\n normalDriftMagnitude: norm(normal),\n curvature: geometry.curvature,\n explainedVariance: geometry.explainedVariance,\n distanceToCentroid: distanceToCentroid(observation, geometry.centroid),\n distanceToNearestNeighbor: nearestDist,\n neighborCount: neighbors.length,\n isDrifting,\n };\n\n previousEmbedding = observation;\n\n if (opts.logger) {\n opts.logger.info(\n {\n manifold: {\n step: ctx.step,\n curvature: parseFloat(geometry.curvature.toFixed(4)),\n explainedVariance: parseFloat(geometry.explainedVariance.toFixed(4)),\n normalDrift: parseFloat(snapshot.normalDriftMagnitude.toFixed(4)),\n nearestNeighbor: parseFloat(nearestDist.toFixed(4)),\n neighbors: neighbors.length,\n isDrifting,\n },\n },\n `[Manifold] Step ${ctx.step}: κ=${geometry.curvature.toFixed(4)}, Drift=${snapshot.normalDriftMagnitude.toFixed(4)}, NearestNeighbor=${nearestDist.toFixed(4)}, Drifting=${isDrifting}`,\n );\n }\n\n // Halt if drift detected and action is 'halt'\n if (isDrifting && driftAction === 'halt') {\n return 'halt' as unknown as StepContext;\n }\n\n return {\n ...ctx,\n metadata: { ...ctx.metadata, manifold: snapshot },\n };\n },\n\n afterStep(_ctx: StepContext, _result: StepResult): Promise {\n return Promise.resolve();\n },\n };\n}\n\n/**\n * Resolve the velocity vector for manifold decomposition.\n *\n * Prefers EKF-filtered velocity from kinematicsMiddleware (metadata['kinematics']).\n * Falls back to raw velocity (current - previous embedding) if kinematics\n * middleware is not present or this is the first step.\n */\nfunction resolveVelocity(\n ctx: StepContext,\n currentEmbedding: VectorN,\n previousEmbedding: VectorN | null,\n): VectorN {\n // Try to read EKF-filtered velocity from kinematics middleware\n const kinematicsData = ctx.metadata['kinematics'] as KinematicsSnapshot | undefined;\n if (kinematicsData?.velocity) {\n return kinematicsData.velocity;\n }\n\n // Fallback: raw velocity from consecutive embeddings\n if (previousEmbedding) {\n return subtract(currentEmbedding, previousEmbedding);\n }\n\n // First step: no velocity available\n return currentEmbedding.map(() => 0);\n}\n\n/**\n * Build a ManifoldSnapshot for degenerate cases (too few neighbors).\n */\nfunction buildDegenerateSnapshot(observation: VectorN, neighborCount: number): ManifoldSnapshot {\n const d = observation.length;\n return {\n velocityTangent: new Array(d).fill(0),\n velocityNormal: new Array(d).fill(0),\n normalDriftMagnitude: 0,\n curvature: 1, // maximally uncertain\n explainedVariance: 0,\n distanceToCentroid: 0,\n distanceToNearestNeighbor: Infinity,\n neighborCount,\n isDrifting: true, // no neighbors = definitely drifting\n };\n}\n\n/**\n * Compute the Euclidean distance from a point to its nearest neighbor.\n */\nfunction nearestNeighborDistance(point: VectorN, neighbors: VectorN[]): number {\n let minDist = Infinity;\n for (const neighbor of neighbors) {\n const d = norm(subtract(point, neighbor));\n if (d < minDist) minDist = d;\n }\n return minDist;\n}\n"]}