@mneme-ai/core 2.19.46 → 2.19.48

package/dist/chronosheaf/pain_catalog.js

@@ -0,0 +1,108 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P1 · pain catalog.
+ *
+ *   Seven user-reported pains from the v2.19.40-46 dogfood cycle. Each
+ *   pain has the same structural shape: every verifier returns OK
+ *   pairwise, but the system as a whole carries a contradiction.
+ *   The catalog encodes (a) the pain, (b) what the current pairwise
+ *   tools see, (c) what they MISS — the missing piece is always a
+ *   topological obstruction the sheaf cohomology layer (P2-a) catches.
+ *
+ *   This file is the formal type-system anchor for the rest of
+ *   CHRONOSHEAF: every new primitive references one or more catalog
+ *   entries via `painId`, so when we audit "does CHRONOSHEAF actually
+ *   cover the user's pain?" the answer is structurally enforced.
+ */
+export const PAIN_CATALOG = Object.freeze([
+    {
+        painId: "PAIN-001",
+        pain: "pulse บอก v2.19.42 latest, npm มี v2.19.43",
+        currentToolsSee: "snapshot freshness at one moment",
+        whatTheyMiss: "time-direction inconsistency — the pulse looks BACKWARD (cache) while npm looks FORWARD (registry); two arrows of time clash without a unifying clock",
+        topology: "time-direction",
+        primitives: ["sheaf", "free_energy"],
+        surfacedIn: "v2.19.40-43 dogfood cycle",
+    },
+    {
+        painId: "PAIN-002",
+        pain: "219 KB capabilities โหลดทุก session",
+        currentToolsSee: "a flat tool list",
+        whatTheyMiss: "scale-appropriate detail — AI agent on cold start needs ≤2 KB summary; only on tool-pick does it need full schema; current tool has ONE detail level",
+        topology: "scale-mismatch",
+        primitives: ["rg_flow", "persistence"],
+        surfacedIn: "v2.19.40 SKINNY CAPABILITIES gap",
+    },
+    {
+        painId: "PAIN-003",
+        pain: "claim '699 tools' → reality 711",
+        currentToolsSee: "a pairwise contradiction between two claim sites",
+        whatTheyMiss: "drift surface — the count crept 685 → 699 → 711 across releases; each step looked locally consistent but the trajectory exposed structural drift",
+        topology: "drift-surface",
+        primitives: ["persistence", "wasserstein"],
+        surfacedIn: "v2.19.34-44 catalog churn",
+    },
+    {
+        painId: "PAIN-004",
+        pain: "HONESTY GATE ตัวเองพังเงียบ ไม่ trigger CI",
+        currentToolsSee: "the gate's stated verdict",
+        whatTheyMiss: "self-referential trust — when the gate audits itself, classical logic risks Russell-style paradox; current tools have no formal way to talk about 'who watches the watcher'",
+        topology: "self-reference",
+        primitives: ["aczel", "sheaf"],
+        surfacedIn: "v2.19.40 HONESTY GATE shipped lying",
+    },
+    {
+        painId: "PAIN-005",
+        pain: "welcome --json '{}' โยน แม้ MCP family รับ",
+        currentToolsSee: "per-command schema",
+        whatTheyMiss: "interface coherence as a global obstruction — every command's --json shape needs to be a section of the same sheaf over the command tree; mismatch = H¹ ≠ 0",
+        topology: "interface-coherence",
+        primitives: ["sheaf", "tropical"],
+        surfacedIn: "v2.19.40-45 N6 4-round bug",
+    },
+    {
+        painId: "PAIN-006",
+        pain: "verify confidence 60% — ไม่ derive จากอะไร",
+        currentToolsSee: "a heuristic number",
+        whatTheyMiss: "mathematical guarantee — confidence should be a posterior derived from Bayesian update OR a measure-theoretic bound (Chebyshev / Hoeffding), not a vibe",
+        topology: "epistemic-confidence",
+        primitives: ["free_energy", "wasserstein"],
+        surfacedIn: "v2.19.44 OSMOSIS posterior gap",
+    },
+    {
+        painId: "PAIN-007",
+        pain: "self-upgrade Windows DLL lock (libvips EBUSY)",
+        currentToolsSee: "an OS-level error message",
+        whatTheyMiss: "action that changes the substrate of the actor itself — the running mneme.cmd IS the file being overwritten; classical action models don't handle the actor mutating its own world",
+        topology: "substrate-mutation",
+        primitives: ["aczel", "free_energy"],
+        surfacedIn: "v2.19.41-45 npm install EBUSY",
+    },
+]);
+export function catalogStats() {
+    const byTopology = {};
+    const byPrimitive = {};
+    for (const e of PAIN_CATALOG) {
+        byTopology[e.topology] = (byTopology[e.topology] ?? 0) + 1;
+        for (const p of e.primitives)
+            byPrimitive[p] = (byPrimitive[p] ?? 0) + 1;
+    }
+    const primitiveLoad = Object.entries(byPrimitive)
+        .map(([tag, pains]) => ({ tag: tag, pains }))
+        .sort((a, b) => b.pains - a.pains);
+    return {
+        totalPains: PAIN_CATALOG.length,
+        byTopology: byTopology,
+        byPrimitive: byPrimitive,
+        primitiveLoad,
+    };
+}
+/** Look up every pain that a given primitive addresses. */
+export function painsForPrimitive(tag) {
+    return PAIN_CATALOG.filter((e) => e.primitives.includes(tag));
+}
+/** Look up every primitive needed for a given pain. */
+export function primitivesForPain(painId) {
+    const e = PAIN_CATALOG.find((x) => x.painId === painId);
+    return e ? [...e.primitives] : [];
+}
+//# sourceMappingURL=pain_catalog.js.map

package/dist/chronosheaf/pain_catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pain_catalog.js","sourceRoot":"","sources":["../../src/chronosheaf/pain_catalog.ts"],"names":[],"mappings":"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"}

package/dist/chronosheaf/persistence.d.ts

@@ -0,0 +1,79 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-c · persistent homology.
+ *
+ *   Math foundation (Edelsbrunner / Carlsson, ~2002-2008):
+ *
+ *     A filtration is a nested sequence of simplicial complexes
+ *
+ *       ∅ = K_0 ⊆ K_1 ⊆ K_2 ⊆ … ⊆ K_n.
+ *
+ *     For each k, the inclusion K_i ↪ K_j induces a map
+ *     H_k(K_i) → H_k(K_j). A class c ∈ H_k IS BORN at filtration b if
+ *     it appears in K_b but not in K_{b−1}, and DIES at d > b if it
+ *     becomes a boundary in K_d. The persistence pair (b, d) with
+ *     pers(b, d) = d − b measures structural robustness; long-lived
+ *     features survive coarse-graining + noise and represent
+ *     real structure, while short-lived ones are noise.
+ *
+ *     The Persistence Diagram (or Bar Code) PD_k = {(b, d) : (b, d)
+ *     is a persistence pair} is the canonical invariant. It satisfies
+ *     a stability theorem (Cohen-Steiner / Edelsbrunner / Harer 2007):
+ *     bottleneck distance W_∞(PD(f), PD(g)) ≤ ‖f − g‖_∞.
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     We filter the tool-catalog over releases: K_i = the catalog at
+ *     release v_i, with each tool name as a 0-simplex and each
+ *     "is registered" relation as a 1-simplex. A persistent 0-class
+ *     = a tool present continuously across releases. A 0-class that
+ *     dies = a tool removed/renamed. A 1-class = a co-registration
+ *     pattern.
+ *
+ *     The persistence diagram answers "which facts survived the last
+ *     N releases" in a single picture, and bottleneck distance gives a
+ *     rigorous "how much did the catalog drift" metric for PAIN-003.
+ *
+ *   Implementation: standard column-reduction algorithm (Zomorodian-
+ *   Carlsson 2005), over ℝ coefficients. We implement the 0-dim
+ *   variant (most useful for catalog facts) + a generic kth-dim wrapper.
+ */
+export interface FiltrationStep {
+    /** Filtration value (e.g. release index or scalar threshold). */
+    value: number;
+    /** Simplices added at this step (each = sorted vertex list). */
+    add: ReadonlyArray<ReadonlyArray<string>>;
+}
+export interface PersistencePair {
+    /** Homology dimension. */
+    dim: number;
+    /** Birth filtration value. */
+    birth: number;
+    /** Death filtration value; +∞ for essential (immortal) classes. */
+    death: number;
+    /** Persistence d − b (∞ for essential). */
+    persistence: number;
+    /** Optional witness — birth simplex + death simplex (vertex tuples). */
+    birthSimplex: ReadonlyArray<string>;
+    deathSimplex?: ReadonlyArray<string>;
+}
+export interface PersistenceDiagram {
+    pairs: PersistencePair[];
+    /** Maximum persistence over the diagram (excluding ∞). */
+    maxFinitePersistence: number;
+    /** Count of essential classes per dimension. */
+    essentialByDim: Record<number, number>;
+}
+/**
+ * Compute 0-dimensional persistent homology from a vertex filtration.
+ * Algorithm: Union-Find with elder rule (Eldership: when two components
+ * merge, the YOUNGER one dies at the merge filtration value).
+ */
+export declare function persistentHomology0(filtration: ReadonlyArray<FiltrationStep>): PersistenceDiagram;
+/**
+ * Bottleneck distance between two persistence diagrams (1D matching).
+ * Uses Wasserstein-∞ approximation via greedy nearest-neighbour matching
+ * (good enough for the AI-memory PAIN-003 drift use case where diagrams
+ * are small). Bottleneck distance W_∞ = max_pair |Δb| ∨ |Δd|.
+ */
+export declare function bottleneckDistance(a: PersistenceDiagram, b: PersistenceDiagram): number;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/chronosheaf/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../src/chronosheaf/persistence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,GAAG,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,eAAe;IAC9B,0BAA0B;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,0DAA0D;IAC1D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,kBAAkB,CAsEjG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,CA+BvF"}

package/dist/chronosheaf/persistence.js

@@ -0,0 +1,173 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-c · persistent homology.
+ *
+ *   Math foundation (Edelsbrunner / Carlsson, ~2002-2008):
+ *
+ *     A filtration is a nested sequence of simplicial complexes
+ *
+ *       ∅ = K_0 ⊆ K_1 ⊆ K_2 ⊆ … ⊆ K_n.
+ *
+ *     For each k, the inclusion K_i ↪ K_j induces a map
+ *     H_k(K_i) → H_k(K_j). A class c ∈ H_k IS BORN at filtration b if
+ *     it appears in K_b but not in K_{b−1}, and DIES at d > b if it
+ *     becomes a boundary in K_d. The persistence pair (b, d) with
+ *     pers(b, d) = d − b measures structural robustness; long-lived
+ *     features survive coarse-graining + noise and represent
+ *     real structure, while short-lived ones are noise.
+ *
+ *     The Persistence Diagram (or Bar Code) PD_k = {(b, d) : (b, d)
+ *     is a persistence pair} is the canonical invariant. It satisfies
+ *     a stability theorem (Cohen-Steiner / Edelsbrunner / Harer 2007):
+ *     bottleneck distance W_∞(PD(f), PD(g)) ≤ ‖f − g‖_∞.
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     We filter the tool-catalog over releases: K_i = the catalog at
+ *     release v_i, with each tool name as a 0-simplex and each
+ *     "is registered" relation as a 1-simplex. A persistent 0-class
+ *     = a tool present continuously across releases. A 0-class that
+ *     dies = a tool removed/renamed. A 1-class = a co-registration
+ *     pattern.
+ *
+ *     The persistence diagram answers "which facts survived the last
+ *     N releases" in a single picture, and bottleneck distance gives a
+ *     rigorous "how much did the catalog drift" metric for PAIN-003.
+ *
+ *   Implementation: standard column-reduction algorithm (Zomorodian-
+ *   Carlsson 2005), over ℝ coefficients. We implement the 0-dim
+ *   variant (most useful for catalog facts) + a generic kth-dim wrapper.
+ */
+/**
+ * Compute 0-dimensional persistent homology from a vertex filtration.
+ * Algorithm: Union-Find with elder rule (Eldership: when two components
+ * merge, the YOUNGER one dies at the merge filtration value).
+ */
+export function persistentHomology0(filtration) {
+    const pairs = [];
+    const parent = new Map();
+    const birthTime = new Map();
+    let maxFinite = 0;
+    let essential = 0;
+    const find = (x) => {
+        let r = x;
+        while (parent.get(r) !== r)
+            r = parent.get(r);
+        let c = x;
+        while (c !== r) {
+            const n = parent.get(c);
+            parent.set(c, r);
+            c = n;
+        }
+        return r;
+    };
+    for (const step of filtration) {
+        // First add all 0-simplices at this filtration (vertices).
+        for (const simplex of step.add) {
+            if (simplex.length === 1) {
+                const v = simplex[0];
+                if (!parent.has(v)) {
+                    parent.set(v, v);
+                    birthTime.set(v, step.value);
+                }
+            }
+        }
+        // Then process 1-simplices = edges (each merges 0-components or creates a 1-class).
+        for (const simplex of step.add) {
+            if (simplex.length !== 2)
+                continue;
+            const a = simplex[0];
+            const b = simplex[1];
+            // Edge implicitly adds endpoints if missing.
+            for (const v of [a, b]) {
+                if (!parent.has(v)) {
+                    parent.set(v, v);
+                    birthTime.set(v, step.value);
+                }
+            }
+            const ra = find(a);
+            const rb = find(b);
+            if (ra === rb)
+                continue;
+            // Merge components — younger dies (elder rule).
+            const ta = birthTime.get(ra) ?? step.value;
+            const tb = birthTime.get(rb) ?? step.value;
+            const youngerRoot = ta > tb ? ra : rb;
+            const elderRoot = ta > tb ? rb : ra;
+            const deathTime = step.value;
+            const birthValue = Math.max(ta, tb);
+            parent.set(youngerRoot, elderRoot);
+            pairs.push({
+                dim: 0, birth: birthValue, death: deathTime,
+                persistence: deathTime - birthValue,
+                birthSimplex: [youngerRoot], deathSimplex: [a, b],
+            });
+            if (deathTime - birthValue > maxFinite)
+                maxFinite = deathTime - birthValue;
+        }
+    }
+    // Surviving components → essential classes (death = +∞).
+    const roots = new Set();
+    for (const v of parent.keys())
+        roots.add(find(v));
+    for (const r of roots) {
+        essential++;
+        pairs.push({
+            dim: 0, birth: birthTime.get(r) ?? 0, death: Infinity,
+            persistence: Infinity, birthSimplex: [r],
+        });
+    }
+    return {
+        pairs,
+        maxFinitePersistence: maxFinite,
+        essentialByDim: { 0: essential },
+    };
+}
+/**
+ * Bottleneck distance between two persistence diagrams (1D matching).
+ * Uses Wasserstein-∞ approximation via greedy nearest-neighbour matching
+ * (good enough for the AI-memory PAIN-003 drift use case where diagrams
+ * are small). Bottleneck distance W_∞ = max_pair |Δb| ∨ |Δd|.
+ */
+export function bottleneckDistance(a, b) {
+    // Take only finite-persistence pairs for matching; essential classes
+    // count toward the "infinity diagonal".
+    const ap = a.pairs.filter((p) => isFinite(p.persistence));
+    const bp = b.pairs.filter((p) => isFinite(p.persistence));
+    const matched = new Set();
+    let worst = 0;
+    for (const p1 of ap) {
+        let bestIdx = -1;
+        let bestDist = Infinity;
+        for (let i = 0; i < bp.length; i++) {
+            if (matched.has(i))
+                continue;
+            const p2 = bp[i];
+            const d = Math.max(Math.abs(p1.birth - p2.birth), Math.abs(p1.death - p2.death));
+            if (d < bestDist) {
+                bestDist = d;
+                bestIdx = i;
+            }
+        }
+        if (bestIdx >= 0) {
+            matched.add(bestIdx);
+            if (bestDist > worst)
+                worst = bestDist;
+        }
+        else {
+            // Unmatched — distance to diagonal = persistence/2.
+            const diag = p1.persistence / 2;
+            if (diag > worst)
+                worst = diag;
+        }
+    }
+    // Account for unmatched pairs in b.
+    for (let i = 0; i < bp.length; i++) {
+        if (matched.has(i))
+            continue;
+        const diag = bp[i].persistence / 2;
+        if (diag > worst)
+            worst = diag;
+    }
+    return worst;
+}
+//# sourceMappingURL=persistence.js.map

package/dist/chronosheaf/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","sourceRoot":"","sources":["../../src/chronosheaf/persistence.ts"],"names":[],"mappings":"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"}

package/dist/chronosheaf/rg_flow.d.ts

@@ -0,0 +1,81 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-b · Renormalization Group flow.
+ *
+ *   Math foundation (Wilson / Kadanoff, 1971):
+ *
+ *     For a scale s ∈ ℝ⁺ and a Hamiltonian (or generic "system state")
+ *     H_s, the RG operator R_b shifts the scale by a factor b:
+ *
+ *       H_{s + log b} = R_b · H_s,   R_b R_{b'} = R_{bb'}.
+ *
+ *     Fixed points H* satisfying R_b H* = H* for some b are
+ *     SCALE-INVARIANT — they survive every coarse-graining step.
+ *     Operators (degrees of freedom) split into RELEVANT (eigenvalue
+ *     |λ| > 1, grow under flow → matter at every scale), MARGINAL
+ *     (|λ| = 1, neither grow nor decay), IRRELEVANT (|λ| < 1, vanish
+ *     under flow → noise that washes out).
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     A coarse-graining is an aggregation step on tool catalog data:
+ *
+ *       state s_0 = full catalog list (~700 tool names)
+ *       R_2 s_0  = family-grouped (governor/fossil/...) (~20 groups)
+ *       R_2² s_0 = category-grouped (memory/audit/meta...) (9 cats)
+ *       R_2³ s_0 = single "all tools" scalar (1 number)
+ *
+ *     Fixed points of this flow are descriptors that DON'T change as we
+ *     zoom out — they're the right-detail-level for any consumer.
+ *     The skinny capabilities tool from v2.19.41 is a hand-rolled
+ *     RG fixed point at scale 2 (category-grouped); CHRONOSHEAF lets
+ *     callers pick any scale by passing `b`.
+ *
+ *   Implementation: linear coarse-graining on vector-valued states,
+ *   eigendecomposition via power iteration for the relevance classifier.
+ *   Pure-function; no fancy numerics required for the AI-memory use case
+ *   because catalog states are small (≤ 1000 dims).
+ */
+export interface RGState {
+    /** Numeric state vector at scale s. */
+    vector: number[];
+    /** Scale exponent (log_b of physical scale). */
+    scale: number;
+    /** Optional label for human inspection. */
+    label?: string;
+}
+export interface RGStep {
+    /** From-scale → to-scale (factor b). */
+    factor: number;
+    /** Aggregator that merges groups of size `factor` into one component. */
+    aggregator: "mean" | "sum" | "max" | "min";
+}
+/** Apply a single RG step: aggregate groups of `factor` adjacent components. */
+export declare function rgStep(s: RGState, step: RGStep): RGState;
+/** Iterate the RG flow until the state stops changing (fixed point) or N steps. */
+export declare function rgFixedPoint(s0: RGState, step: RGStep, maxIter?: number, tol?: number): {
+    state: RGState;
+    iterations: number;
+    reachedFixedPoint: boolean;
+};
+/**
+ * Classify operators by their behaviour under the linearised RG flow.
+ * We treat the state vector as a perturbation around the fixed point and
+ * estimate the leading eigenvalue via power iteration on (R_b)' (linear
+ * approximation).
+ */
+export type Relevance = "relevant" | "marginal" | "irrelevant";
+export declare function classifyRelevance(s0: RGState, step: RGStep, perturbation: number[], iterations?: number): {
+    eigenvalue: number;
+    class: Relevance;
+};
+/**
+ * AI-memory specific: given a catalog snapshot (one number per tool —
+ * e.g. recent invocation count), find the SMALLEST scale b at which
+ * coarse-graining yields ≤ targetSize components. Used by the skinny-
+ * capabilities surface to pick the right family-grouping automatically.
+ */
+export declare function smallestScaleForBudget(s0: RGState, step: RGStep, targetSize: number, maxIter?: number): {
+    state: RGState;
+    iterations: number;
+};
+//# sourceMappingURL=rg_flow.d.ts.map

package/dist/chronosheaf/rg_flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rg_flow.d.ts","sourceRoot":"","sources":["../../src/chronosheaf/rg_flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,MAAM,WAAW,OAAO;IACtB,uCAAuC;IACvC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,MAAM;IACrB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;CAC5C;AAED,gFAAgF;AAChF,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAmBxD;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,SAAK,EAAE,GAAG,SAAQ,GAAG;IAClF,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAC;CAChE,CAaA;AAQD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,CAAC;AAE/D,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EAAE,EACtB,UAAU,SAAK,GACd;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAwB1C;AAQD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,SAAK,GACX;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAOxC"}

package/dist/chronosheaf/rg_flow.js

@@ -0,0 +1,146 @@
+/**
+ * v2.19.47 — CHRONOSHEAF P2-b · Renormalization Group flow.
+ *
+ *   Math foundation (Wilson / Kadanoff, 1971):
+ *
+ *     For a scale s ∈ ℝ⁺ and a Hamiltonian (or generic "system state")
+ *     H_s, the RG operator R_b shifts the scale by a factor b:
+ *
+ *       H_{s + log b} = R_b · H_s,   R_b R_{b'} = R_{bb'}.
+ *
+ *     Fixed points H* satisfying R_b H* = H* for some b are
+ *     SCALE-INVARIANT — they survive every coarse-graining step.
+ *     Operators (degrees of freedom) split into RELEVANT (eigenvalue
+ *     |λ| > 1, grow under flow → matter at every scale), MARGINAL
+ *     (|λ| = 1, neither grow nor decay), IRRELEVANT (|λ| < 1, vanish
+ *     under flow → noise that washes out).
+ *
+ *   AI-memory mapping (PAIN-002 scale-mismatch + PAIN-003 drift-surface):
+ *
+ *     A coarse-graining is an aggregation step on tool catalog data:
+ *
+ *       state s_0 = full catalog list (~700 tool names)
+ *       R_2 s_0  = family-grouped (governor/fossil/...) (~20 groups)
+ *       R_2² s_0 = category-grouped (memory/audit/meta...) (9 cats)
+ *       R_2³ s_0 = single "all tools" scalar (1 number)
+ *
+ *     Fixed points of this flow are descriptors that DON'T change as we
+ *     zoom out — they're the right-detail-level for any consumer.
+ *     The skinny capabilities tool from v2.19.41 is a hand-rolled
+ *     RG fixed point at scale 2 (category-grouped); CHRONOSHEAF lets
+ *     callers pick any scale by passing `b`.
+ *
+ *   Implementation: linear coarse-graining on vector-valued states,
+ *   eigendecomposition via power iteration for the relevance classifier.
+ *   Pure-function; no fancy numerics required for the AI-memory use case
+ *   because catalog states are small (≤ 1000 dims).
+ */
+/** Apply a single RG step: aggregate groups of `factor` adjacent components. */
+export function rgStep(s, step) {
+    const b = Math.max(1, Math.floor(step.factor));
+    if (b <= 1)
+        return { ...s, scale: s.scale + 1 };
+    const out = [];
+    for (let i = 0; i < s.vector.length; i += b) {
+        const block = s.vector.slice(i, Math.min(i + b, s.vector.length));
+        let v;
+        switch (step.aggregator) {
+            case "sum":
+                v = block.reduce((a, x) => a + x, 0);
+                break;
+            case "max":
+                v = Math.max(...block);
+                break;
+            case "min":
+                v = Math.min(...block);
+                break;
+            case "mean":
+            default:
+                v = block.reduce((a, x) => a + x, 0) / block.length;
+                break;
+        }
+        out.push(v);
+    }
+    const result = { vector: out, scale: s.scale + Math.log2(b) };
+    if (s.label !== undefined)
+        result.label = s.label;
+    return result;
+}
+/** Iterate the RG flow until the state stops changing (fixed point) or N steps. */
+export function rgFixedPoint(s0, step, maxIter = 50, tol = 1e-12) {
+    let cur = s0;
+    for (let i = 0; i < maxIter; i++) {
+        const next = rgStep(cur, step);
+        if (vecClose(cur.vector, next.vector, tol)) {
+            return { state: next, iterations: i + 1, reachedFixedPoint: true };
+        }
+        if (next.vector.length <= 1) {
+            return { state: next, iterations: i + 1, reachedFixedPoint: true };
+        }
+        cur = next;
+    }
+    return { state: cur, iterations: maxIter, reachedFixedPoint: false };
+}
+function vecClose(a, b, tol) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (Math.abs((a[i] ?? 0) - (b[i] ?? 0)) > tol)
+            return false;
+    return true;
+}
+export function classifyRelevance(s0, step, perturbation, iterations = 20) {
+    // Apply RG `iterations` times to the perturbation only; measure growth.
+    let cur = [...perturbation];
+    let firstNorm = vecNorm(cur);
+    if (firstNorm < 1e-15)
+        return { eigenvalue: 0, class: "irrelevant" };
+    void s0; // RG flow linearised about fixed point — only step shape matters
+    let lastNorm = firstNorm;
+    let lastRatio = 1;
+    for (let k = 0; k < iterations; k++) {
+        const next = rgStep({ vector: cur, scale: 0 }, step).vector;
+        const nNorm = vecNorm(next);
+        if (nNorm < 1e-15) {
+            lastRatio = 0;
+            break;
+        }
+        lastRatio = nNorm / lastNorm;
+        cur = next;
+        lastNorm = nNorm;
+        if (cur.length <= 1)
+            break;
+    }
+    // Eigenvalue λ ≈ growth ratio per iteration.
+    const eigenvalue = lastRatio;
+    let cls;
+    if (eigenvalue > 1 + 1e-3)
+        cls = "relevant";
+    else if (eigenvalue < 1 - 1e-3)
+        cls = "irrelevant";
+    else
+        cls = "marginal";
+    return { eigenvalue, class: cls };
+}
+function vecNorm(v) {
+    let s = 0;
+    for (const x of v)
+        s += x * x;
+    return Math.sqrt(s);
+}
+/**
+ * AI-memory specific: given a catalog snapshot (one number per tool —
+ * e.g. recent invocation count), find the SMALLEST scale b at which
+ * coarse-graining yields ≤ targetSize components. Used by the skinny-
+ * capabilities surface to pick the right family-grouping automatically.
+ */
+export function smallestScaleForBudget(s0, step, targetSize, maxIter = 50) {
+    let cur = s0;
+    for (let i = 0; i < maxIter; i++) {
+        if (cur.vector.length <= targetSize)
+            return { state: cur, iterations: i };
+        cur = rgStep(cur, step);
+    }
+    return { state: cur, iterations: maxIter };
+}
+//# sourceMappingURL=rg_flow.js.map

package/dist/chronosheaf/rg_flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rg_flow.js","sourceRoot":"","sources":["../../src/chronosheaf/rg_flow.ts"],"names":[],"mappings":"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"}