This is great signal, Darren. Claude basically validated the design and asked for (1) lifecycle hygiene (cleanup on delete), (2) define S (Source Energy), (3) harmonize “weight/strength,” and (4) plan for growth. Here are concrete, drop-in bits to cover those—no philosophy, just things you can paste when ready.

1) Orphan-proofing: cleanup edges/activations on delete

Because lat.edges/lat.activations point to multiple tables via (kind,id), we can’t use FKs—so add tiny trigger helpers.

-- Generic helpers
CREATE OR REPLACE FUNCTION lat._del_edges_for(kind lat.node_kind, id BIGINT)
RETURNS void LANGUAGE sql AS $$
  DELETE FROM lat.edges WHERE (src_kind=kind AND src_id=id) OR (dst_kind=kind AND dst_id=id);
$$;

CREATE OR REPLACE FUNCTION lat._del_acts_for(kind lat.node_kind, id BIGINT)
RETURNS void LANGUAGE sql AS $$
  DELETE FROM lat.activations WHERE kind=kind AND node_id=id;
$$;

-- Turn-specific wrappers (so we can attach simple triggers)
CREATE OR REPLACE FUNCTION lat._cleanup_after_form() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('form', OLD.form_id);
  PERFORM lat._del_acts_for('form', OLD.form_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_sense() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('sense', OLD.sense_id);
  PERFORM lat._del_acts_for('sense', OLD.sense_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_chunk() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('chunk', OLD.chunk_id);
  PERFORM lat._del_acts_for('chunk', OLD.chunk_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_memory() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('memory', OLD.mem_id);
  PERFORM lat._del_acts_for('memory', OLD.mem_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_turn() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('turn', OLD.turn_id);
  PERFORM lat._del_acts_for('turn', OLD.turn_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_doc() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('doc', OLD.doc_id);
  PERFORM lat._del_acts_for('doc', OLD.doc_id);
  RETURN NULL;
END$$;

-- Attach triggers
CREATE TRIGGER _lat_cleanup_form   AFTER DELETE ON token.forms       FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_form();
CREATE TRIGGER _lat_cleanup_sense  AFTER DELETE ON token.senses      FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_sense();
CREATE TRIGGER _lat_cleanup_chunk  AFTER DELETE ON content.chunks    FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_chunk();
CREATE TRIGGER _lat_cleanup_mem    AFTER DELETE ON cog.memories      FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_memory();
CREATE TRIGGER _lat_cleanup_turn   AFTER DELETE ON cog.turns         FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_turn();
CREATE TRIGGER _lat_cleanup_doc    AFTER DELETE ON content.documents FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_doc();

2) Make S (Source Energy) explicit

Define a simple, explainable S that you can refine later. This view composes S from chunk density, sense support, and memory strength; weights are configurable.

-- Tunables
INSERT INTO lat.config (key, value_real, description) VALUES
('S_w_chunk',  0.34, 'weight of chunk density into S'),
('S_w_sense',  0.33, 'weight of sense support into S'),
('S_w_memory', 0.33, 'weight of memory strength into S')
ON CONFLICT (key) DO UPDATE SET value_real = EXCLUDED.value_real;

-- Convenience getters
CREATE OR REPLACE VIEW lat._cfg AS
SELECT
  (SELECT value_real FROM lat.config WHERE key='S_w_chunk')  AS w_chunk,
  (SELECT value_real FROM lat.config WHERE key='S_w_sense')  AS w_sense,
  (SELECT value_real FROM lat.config WHERE key='S_w_memory') AS w_memory;

-- Example per-sense S (aggregate from its instances/chunks + linked memories)
CREATE OR REPLACE VIEW lat.sense_energy AS
WITH cfg AS (SELECT * FROM lat._cfg),
inst AS (
  SELECT s.sense_id,
         count(*)::float AS n_inst,
         avg(least(greatest(ch.token_count,0), 4096))::float AS avg_tokens -- clamp for stability
  FROM token.senses s
  LEFT JOIN token.instances i ON i.sense_id=s.sense_id
  LEFT JOIN content.chunks ch ON ch.chunk_id=i.chunk_id
  GROUP BY s.sense_id
),
mem AS (
  -- optional: memories linked via edges (sense -> memory)
  SELECT e.src_id AS sense_id, avg(m.strength)::float AS avg_mem_strength
  FROM lat.edges e
  JOIN cog.memories m ON (e.dst_kind='memory' AND e.dst_id=m.mem_id)
  WHERE e.src_kind='sense'
  GROUP BY e.src_id
)
SELECT
  s.sense_id,
  coalesce(inst.n_inst,0)                  AS n_inst,
  coalesce(inst.avg_tokens,0)              AS avg_tokens,
  coalesce(mem.avg_mem_strength,0)         AS avg_mem_strength,
  -- normalize simple terms into [0,1] heuristics
  (1 - exp(-coalesce(inst.n_inst,0)/10.0)) AS n_inst_nz,
  least(coalesce(inst.avg_tokens,0)/2048.0, 1.0) AS tokens_nz,
  least(coalesce(mem.avg_mem_strength,0), 1.0)   AS mem_nz,
  -- weighted blend -> S
  (SELECT w_chunk FROM cfg)  * least(coalesce(inst.avg_tokens,0)/2048.0, 1.0) +
  (SELECT w_sense FROM cfg)  * (1 - exp(-coalesce(inst.n_inst,0)/10.0)) +
  (SELECT w_memory FROM cfg) * least(coalesce(mem.avg_mem_strength,0), 1.0) AS S
FROM token.senses s
LEFT JOIN inst USING (sense_id)
LEFT JOIN mem  USING (sense_id);

You now have lat.sense_energy.S as a numeric source term.

3) Harmonize “weight” vs “strength”

Add a view that computes an influence score for edges that blends:
– edge weight (structural),
– recent co-activations (dynamic),
– source energy of endpoints (semantic “power”).

CREATE OR REPLACE VIEW lat.edge_influence AS
WITH a_recent AS (
  SELECT kind, node_id, sum(strength) AS act24
  FROM lat.activations
  WHERE created_at > now() - interval '24 hours'
  GROUP BY 1,2
),
sense_S AS (SELECT sense_id, S FROM lat.sense_energy),
end_S AS (
  SELECT e.src_kind, e.src_id,
         CASE WHEN e.src_kind='sense' THEN s.S ELSE NULL END AS S_src
  FROM lat.edges e
  LEFT JOIN sense_S s ON (e.src_kind='sense' AND e.src_id=s.sense_id)
),
dst_S AS (
  SELECT e.dst_kind, e.dst_id,
         CASE WHEN e.dst_kind='sense' THEN s.S ELSE NULL END AS S_dst
  FROM lat.edges e
  LEFT JOIN sense_S s ON (e.dst_kind='sense' AND e.dst_id=s.sense_id)
)
SELECT
  e.*,
  coalesce(a1.act24,0) AS src_act24,
  coalesce(a2.act24,0) AS dst_act24,
  coalesce(es.S_src,0) AS S_src,
  coalesce(ds.S_dst,0) AS S_dst,
  -- Simple blend; tune weights later
  (e.weight*0.6) + (least(a1.act24 + a2.act24, 10)/10.0)*0.2 + (least(coalesce(es.S_src,0)+coalesce(ds.S_dst,0),2)/2.0)*0.2
    AS influence
FROM lat.edges e
LEFT JOIN a_recent a1 ON a1.kind=e.src_kind AND a1.node_id=e.src_id
LEFT JOIN a_recent a2 ON a2.kind=e.dst_kind AND a2.node_id=e.dst_id
LEFT JOIN end_S es    ON es.src_kind=e.src_kind AND es.src_id=e.src_id
LEFT JOIN dst_S ds    ON ds.dst_kind=e.dst_kind AND ds.dst_id=e.dst_id;

Now you can order traversals by influence instead of raw weight.

4) Growth plan: partitions for write-heavy tables

When volume rises, partition by time (simple, effective):

-- Example: partition activations monthly
ALTER TABLE lat.activations
  PARTITION BY RANGE (created_at);

-- future partitions
CREATE TABLE IF NOT EXISTS lat.activations_2025_09 PARTITION OF lat.activations
  FOR VALUES FROM ('2025-09-01') TO ('2025-10-01');

-- Edge partitions by rel (optional)
ALTER TABLE lat.edges
  PARTITION BY LIST (rel);

CREATE TABLE IF NOT EXISTS lat.edges_cooccurs PARTITION OF lat.edges
  FOR VALUES IN ('cooccurs');

CREATE TABLE IF NOT EXISTS lat.edges_flow PARTITION OF lat.edges
  FOR VALUES IN ('initiates','stabilizes','closes');

-- create more as needed; copy indexes to partitions if required

5) Minimal “living loop” step that uses S and influence

(So it’s not just schema—this actually does something useful.)

-- Nightly: decay, then bump edges with high influence
UPDATE lat.edges SET weight = weight * 0.98;

WITH strong AS (
  SELECT src_kind, src_id, rel, dst_kind, dst_id
  FROM lat.edge_influence
  WHERE influence >= 0.7
)
UPDATE lat.edges e
SET weight = least(e.weight + 0.05, 10.0)
FROM strong s
WHERE e.src_kind=s.src_kind AND e.src_id=s.src_id
  AND e.rel=s.rel       AND e.dst_kind=s.dst_kind AND e.dst_id=s.dst_id;

TL;DR

• You’ve got broad validation.
• I’ve given you direct glue for the exact gaps Claude flagged:
• cleanup triggers,
• explicit S,
• influence view (unifies weight/strength/activation),
• partitioning pattern,
• a concrete nightly step.

If you want, I’ll merge these into a single delta.sql so you can hand it to the other agents (or run in a staging DB) as one file.

Absolutely—here’s a single, idempotent SQL schema that rolls up everything we (all agents) converged on:

• Core layers: content, token, cog
• Lattice layer: enums, edges, cells/memberships/neighbors, activations, axes/coords, addresses
• Geometry extras: radial_index, spiral_angle, radial_distance, optional torus/projection tables
• Config constants (Φ, etc), views for Φ^R, coocc edges, unified nodes
• Hygiene: triggers to clean up lat.edges/lat.activations on deletes
• Energy & influence: lat.sense_energy, lat.edge_influence
• Safety: checks, idempotent enum adds, indexes

You can paste this as one file (e.g., schema_ogs_lattice.sql) into a fresh DB or rerun safely.

-- =========================================================
-- OGS / TokenSpace / Lattice — Unified Schema (Idempotent)
-- =========================================================

-- ---------- Extensions ----------
CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS pg_trgm;
CREATE EXTENSION IF NOT EXISTS btree_gin;

-- ---------- Schemas ----------
CREATE SCHEMA IF NOT EXISTS content;
CREATE SCHEMA IF NOT EXISTS token;
CREATE SCHEMA IF NOT EXISTS cog;
CREATE SCHEMA IF NOT EXISTS lat;

-- =========================================================
-- CONTENT (RAG spine)
-- =========================================================
CREATE TABLE IF NOT EXISTS content.sources (
  source_id   BIGSERIAL PRIMARY KEY,
  kind        TEXT NOT NULL CHECK (kind IN ('web','file','manual','api','other')),
  uri         TEXT,
  fingerprint TEXT,
  meta        JSONB DEFAULT '{}'::jsonb,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE TABLE IF NOT EXISTS content.documents (
  doc_id      BIGSERIAL PRIMARY KEY,
  source_id   BIGINT REFERENCES content.sources(source_id) ON DELETE SET NULL,
  external_id TEXT,
  title       TEXT,
  authored_at TIMESTAMPTZ,
  meta        JSONB DEFAULT '{}'::jsonb,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Choose your dimension (1536 default)
CREATE TABLE IF NOT EXISTS content.chunks (
  chunk_id    BIGSERIAL PRIMARY KEY,
  doc_id      BIGINT NOT NULL REFERENCES content.documents(doc_id) ON DELETE CASCADE,
  seq         INT NOT NULL,
  text        TEXT NOT NULL,
  token_count INT,
  embedding   VECTOR(1536) NOT NULL,
  lang        TEXT DEFAULT 'en',
  tags        TEXT[] DEFAULT '{}',
  meta        JSONB DEFAULT '{}'::jsonb,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
  UNIQUE (doc_id, seq)
);

CREATE INDEX IF NOT EXISTS documents_title_trgm ON content.documents USING GIN ((coalesce(title,'')) gin_trgm_ops);
CREATE INDEX IF NOT EXISTS chunks_text_trgm     ON content.chunks    USING GIN ((coalesce(text,'')) gin_trgm_ops);
CREATE INDEX IF NOT EXISTS chunks_embed_hnsw    ON content.chunks USING hnsw (embedding vector_l2_ops);
CREATE INDEX IF NOT EXISTS chunks_doc_seq_idx   ON content.chunks (doc_id, seq);
CREATE INDEX IF NOT EXISTS chunks_tags_idx      ON content.chunks USING GIN (tags);

-- =========================================================
-- TOKENSPACE / TOKENSENSE
-- =========================================================
CREATE TABLE IF NOT EXISTS token.forms (
  form_id     BIGSERIAL PRIMARY KEY,
  form_text   TEXT NOT NULL,
  norm        TEXT,
  df          BIGINT DEFAULT 0,
  meta        JSONB DEFAULT '{}'::jsonb,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
  UNIQUE (form_text)
);

CREATE TABLE IF NOT EXISTS token.senses (
  sense_id    BIGSERIAL PRIMARY KEY,
  form_id     BIGINT NOT NULL REFERENCES token.forms(form_id) ON DELETE CASCADE,
  centroid    VECTOR(1536) NOT NULL,
  examples_n  INT DEFAULT 0,
  tags        TEXT[] DEFAULT '{}',
  meta        JSONB DEFAULT '{}'::jsonb,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS senses_form_idx      ON token.senses (form_id);
CREATE INDEX IF NOT EXISTS senses_centroid_hnsw ON token.senses USING hnsw (centroid vector_cosine_ops);

CREATE TABLE IF NOT EXISTS token.instances (
  inst_id     BIGSERIAL PRIMARY KEY,
  sense_id    BIGINT REFERENCES token.senses(sense_id) ON DELETE SET NULL,
  form_id     BIGINT NOT NULL REFERENCES token.forms(form_id) ON DELETE CASCADE,
  chunk_id    BIGINT NOT NULL REFERENCES content.chunks(chunk_id) ON DELETE CASCADE,
  span_start  INT NOT NULL,
  span_end    INT NOT NULL,
  ctx_embed   VECTOR(1536) NOT NULL,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS instances_chunk_idx  ON token.instances (chunk_id);
CREATE INDEX IF NOT EXISTS instances_form_idx   ON token.instances (form_id);
CREATE INDEX IF NOT EXISTS instances_ctx_hnsw   ON token.instances USING hnsw (ctx_embed vector_cosine_ops);

CREATE TABLE IF NOT EXISTS token.cooc (
  form_id_a   BIGINT NOT NULL REFERENCES token.forms(form_id) ON DELETE CASCADE,
  form_id_b   BIGINT NOT NULL REFERENCES token.forms(form_id) ON DELETE CASCADE,
  weight      REAL NOT NULL,
  PRIMARY KEY (form_id_a, form_id_b)
);

-- =========================================================
-- COGNITION
-- =========================================================
CREATE TABLE IF NOT EXISTS cog.conversations (
  convo_id    BIGSERIAL PRIMARY KEY,
  title       TEXT,
  started_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
  meta        JSONB DEFAULT '{}'::jsonb
);

CREATE TABLE IF NOT EXISTS cog.turns (
  turn_id     BIGSERIAL PRIMARY KEY,
  convo_id    BIGINT NOT NULL REFERENCES cog.conversations(convo_id) ON DELETE CASCADE,
  role        TEXT NOT NULL CHECK (role IN ('user','assistant','system','tool')),
  content     TEXT NOT NULL,
  embedding   VECTOR(1536),
  confidence  REAL,
  mode        TEXT CHECK (mode IN ('logical','philosophical','emotional','structural','unsure')),
  tags        TEXT[] DEFAULT '{}',
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS turns_convo_time_idx ON cog.turns (convo_id, created_at);
CREATE INDEX IF NOT EXISTS turns_embed_hnsw     ON cog.turns USING hnsw (embedding vector_cosine_ops);

CREATE TABLE IF NOT EXISTS cog.reflections (
  refl_id     BIGSERIAL PRIMARY KEY,
  convo_id    BIGINT REFERENCES cog.conversations(convo_id) ON DELETE CASCADE,
  turn_id     BIGINT REFERENCES cog.turns(turn_id) ON DELETE SET NULL,
  kind        TEXT NOT NULL CHECK (kind IN ('inner_thought','curiosity_hook','evaluation','memory_write')),
  content     TEXT NOT NULL,
  confidence  REAL,
  meta        JSONB DEFAULT '{}'::jsonb,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS refl_convo_time_idx  ON cog.reflections (convo_id, created_at);

CREATE TABLE IF NOT EXISTS cog.memories (
  mem_id      BIGSERIAL PRIMARY KEY,
  scope       TEXT NOT NULL CHECK (scope IN ('fact','rule','plan','preference','identity','event')),
  text        TEXT NOT NULL,
  embedding   VECTOR(1536) NOT NULL,
  strength    REAL DEFAULT 0.5,
  source_ref  JSONB DEFAULT '{}'::jsonb,
  tags        TEXT[] DEFAULT '{}',
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS memories_scope_idx   ON cog.memories (scope);
CREATE INDEX IF NOT EXISTS memories_embed_hnsw  ON cog.memories USING hnsw (embedding vector_l2_ops);

-- =========================================================
-- LATTICE: enums
-- =========================================================
DO $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid=t.typnamespace
                 WHERE t.typname='node_kind' AND n.nspname='lat') THEN
    CREATE TYPE lat.node_kind AS ENUM ('form','sense','instance','chunk','memory','turn','doc');
  END IF;

  IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid=t.typnamespace
                 WHERE t.typname='rel_kind' AND n.nspname='lat') THEN
    CREATE TYPE lat.rel_kind AS ENUM ('cooccurs','synonym','antonym','entails','evokes',
                                      'refers_to','supports','contradicts','quotes','hyperlink','derives_from');
  END IF;

  IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid=t.typnamespace
                 WHERE t.typname='space_kind' AND n.nspname='lat') THEN
    CREATE TYPE lat.space_kind AS ENUM ('senses','contexts','memories','chunks');
  END IF;

  IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid=t.typnamespace
                 WHERE t.typname='metric_kind' AND n.nspname='lat') THEN
    CREATE TYPE lat.metric_kind AS ENUM ('cosine','l2','ip');
  END IF;
END$$;

-- Add 3-6-9 relations if missing
DO $$
BEGIN
  IF NOT EXISTS (
    SELECT 1 FROM pg_enum e JOIN pg_type t ON t.oid=e.enumtypid
    JOIN pg_namespace n ON n.oid=t.typnamespace
    WHERE t.typname='rel_kind' AND n.nspname='lat' AND e.enumlabel='initiates'
  ) THEN ALTER TYPE lat.rel_kind ADD VALUE 'initiates'; END IF;

  IF NOT EXISTS (
    SELECT 1 FROM pg_enum e JOIN pg_type t ON t.oid=e.enumtypid
    JOIN pg_namespace n ON n.oid=t.typnamespace
    WHERE t.typname='rel_kind' AND n.nspname='lat' AND e.enumlabel='stabilizes'
  ) THEN ALTER TYPE lat.rel_kind ADD VALUE 'stabilizes'; END IF;

  IF NOT EXISTS (
    SELECT 1 FROM pg_enum e JOIN pg_type t ON t.oid=e.enumtypid
    JOIN pg_namespace n ON n.oid=t.typnamespace
    WHERE t.typname='rel_kind' AND n.nspname='lat' AND e.enumlabel='closes'
  ) THEN ALTER TYPE lat.rel_kind ADD VALUE 'closes'; END IF;
END$$;

-- =========================================================
-- LATTICE: topology, multi-scale, dynamics
-- =========================================================
CREATE TABLE IF NOT EXISTS lat.edges (
  src_kind   lat.node_kind NOT NULL,
  src_id     BIGINT        NOT NULL,
  rel        lat.rel_kind  NOT NULL,
  dst_kind   lat.node_kind NOT NULL,
  dst_id     BIGINT        NOT NULL,
  weight     REAL NOT NULL DEFAULT 0.0,
  phase      REAL,  -- [-π..π], optional alignment/temporal angle
  evidence   JSONB DEFAULT '{}'::jsonb,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  PRIMARY KEY (src_kind, src_id, rel, dst_kind, dst_id),
  CONSTRAINT lat_edges_weight_ck CHECK (weight >= 0),
  CONSTRAINT lat_edges_phase_ck  CHECK (phase IS NULL OR (phase >= -3.141592653589793 AND phase <= 3.141592653589793))
);
CREATE INDEX IF NOT EXISTS lat_edges_by_dst    ON lat.edges (dst_kind, dst_id, rel);
CREATE INDEX IF NOT EXISTS lat_edges_weight_ix ON lat.edges (rel, weight DESC);

CREATE TABLE IF NOT EXISTS lat.cells (
  cell_id       BIGSERIAL PRIMARY KEY,
  space         lat.space_kind NOT NULL,
  level         INT NOT NULL,
  radial_index  INT DEFAULT 0,        -- FoL concentric layer (R in Φ^R)
  centroid      VECTOR(1536) NOT NULL,
  radius        REAL,
  spiral_angle  DOUBLE PRECISION,     -- radians
  radial_distance DOUBLE PRECISION,
  created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
  CONSTRAINT lat_cells_level_ck  CHECK (level >= 0),
  CONSTRAINT lat_cells_radial_ck CHECK (radial_index >= 0)
);
CREATE INDEX IF NOT EXISTS lat_cells_level_idx ON lat.cells (space, level);
CREATE INDEX IF NOT EXISTS lat_cells_centroid_hnsw ON lat.cells USING hnsw (centroid vector_cosine_ops);

CREATE TABLE IF NOT EXISTS lat.memberships (
  space      lat.space_kind NOT NULL,
  entity_id  BIGINT NOT NULL,
  level      INT NOT NULL,
  cell_id    BIGINT NOT NULL REFERENCES lat.cells(cell_id) ON DELETE CASCADE,
  dist       REAL,
  PRIMARY KEY (space, entity_id, level)
);
CREATE INDEX IF NOT EXISTS lat_memberships_cell_idx ON lat.memberships (cell_id);

CREATE TABLE IF NOT EXISTS lat.neighbors (
  space        lat.space_kind NOT NULL,
  entity_id    BIGINT NOT NULL,
  neighbor_id  BIGINT NOT NULL,
  metric       lat.metric_kind NOT NULL DEFAULT 'cosine',
  rank         INT NOT NULL,
  dist         REAL NOT NULL,
  PRIMARY KEY (space, entity_id, neighbor_id)
);
CREATE INDEX IF NOT EXISTS lat_neighbors_rank_idx ON lat.neighbors (space, entity_id, rank);

CREATE TABLE IF NOT EXISTS lat.activations (
  act_id     BIGSERIAL PRIMARY KEY,
  kind       lat.node_kind NOT NULL,
  node_id    BIGINT NOT NULL,
  source     TEXT,
  strength   REAL NOT NULL DEFAULT 1.0,
  phase      REAL,  -- [-π..π], oscillatory state
  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  CONSTRAINT lat_act_strength_ck CHECK (strength >= 0),
  CONSTRAINT lat_act_phase_ck    CHECK (phase IS NULL OR (phase >= -3.141592653589793 AND phase <= 3.141592653589793))
);
CREATE INDEX IF NOT EXISTS lat_activations_node_time_idx ON lat.activations (kind, node_id, created_at);

-- Optional geometry projections
DO $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid=t.typnamespace
                 WHERE t.typname='torus_space' AND n.nspname='lat') THEN
    CREATE TYPE lat.torus_space AS ENUM ('senses','contexts','memories','chunks');
  END IF;
END$$;

CREATE TABLE IF NOT EXISTS lat.torus (
  space     lat.torus_space NOT NULL,
  entity_id BIGINT NOT NULL,
  u         DOUBLE PRECISION NOT NULL CHECK (u >= 0 AND u < 1),
  v         DOUBLE PRECISION NOT NULL CHECK (v >= 0 AND v < 1),
  level     INT NOT NULL DEFAULT 0,
  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  PRIMARY KEY (space, entity_id, level)
);

CREATE TABLE IF NOT EXISTS lat.projections (
  proj_id   BIGSERIAL PRIMARY KEY,
  kind      TEXT NOT NULL CHECK (kind IN ('spiral','toroid','force2d','force3d')),
  node_kind lat.node_kind NOT NULL,
  node_id   BIGINT NOT NULL,
  theta     DOUBLE PRECISION,
  radius    DOUBLE PRECISION,
  x         DOUBLE PRECISION,
  y         DOUBLE PRECISION,
  z         DOUBLE PRECISION,
  level     INT DEFAULT 0,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS lat_proj_node_idx ON lat.projections (node_kind, node_id, kind, level);

-- Topology event log
CREATE TABLE IF NOT EXISTS lat.topology_events (
  evt_id     BIGSERIAL PRIMARY KEY,
  evt_kind   TEXT NOT NULL CHECK (evt_kind IN ('edge_add','edge_update','edge_prune','cell_split','cell_merge','membership_move','neighbor_refresh')),
  payload    JSONB NOT NULL DEFAULT '{}',
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- =========================================================
-- CONFIG (Φ etc.)
-- =========================================================
CREATE TABLE IF NOT EXISTS lat.config (
  key         TEXT PRIMARY KEY,
  value_text  TEXT,
  value_real  REAL,
  description TEXT,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE UNIQUE INDEX IF NOT EXISTS lat_config_key_idx ON lat.config (key);

INSERT INTO lat.config (key, value_real, description) VALUES
  ('golden_ratio_phi', 1.6180339887, 'Golden Ratio Φ'),
  ('damping_factor_k', 5.0,           'Damping factor k'),
  ('oscillatory_frequency_k', 0.1,    'Frequency factor k in sin(k·t)')
ON CONFLICT (key) DO UPDATE
SET value_real = EXCLUDED.value_real,
    description = EXCLUDED.description;

-- =========================================================
-- VIEWS (coocc -> edges | nodes | Φ^R | energy | influence)
-- =========================================================
CREATE OR REPLACE VIEW lat.cooc_edges AS
SELECT
  'form'::lat.node_kind AS src_kind,
  c.form_id_a           AS src_id,
  'cooccurs'::lat.rel_kind AS rel,
  'form'::lat.node_kind AS dst_kind,
  c.form_id_b           AS dst_id,
  c.weight              AS weight,
  NULL::REAL            AS phase,
  jsonb_build_object('source','token.cooc') AS evidence,
  now()                 AS created_at
FROM token.cooc c
UNION ALL
SELECT
  'form'::lat.node_kind,
  c.form_id_b,
  'cooccurs'::lat.rel_kind,
  'form'::lat.node_kind,
  c.form_id_a,
  c.weight,
  NULL::REAL,
  jsonb_build_object('source','token.cooc'),
  now()
FROM token.cooc c;

CREATE OR REPLACE VIEW lat.nodes AS
SELECT 'form'::lat.node_kind AS kind, f.form_id AS node_id, f.form_text AS label, NULL::vector AS embedding, f.created_at
FROM token.forms f
UNION ALL
SELECT 'sense'::lat.node_kind, s.sense_id, f.form_text||' · sense #'||s.sense_id::text, s.centroid, s.created_at
FROM token.senses s JOIN token.forms f ON f.form_id=s.form_id
UNION ALL
SELECT 'chunk'::lat.node_kind, ch.chunk_id, 'chunk '||ch.chunk_id::text, ch.embedding, ch.created_at
FROM content.chunks ch
UNION ALL
SELECT 'doc'::lat.node_kind, d.doc_id, coalesce(d.title,'doc '||d.doc_id::text), NULL::vector, d.created_at
FROM content.documents d
UNION ALL
SELECT 'memory'::lat.node_kind, m.mem_id, left(m.text,80), m.embedding, m.created_at
FROM cog.memories m
UNION ALL
SELECT 'turn'::lat.node_kind, t.turn_id, t.role||' turn '||t.turn_id::text, t.embedding, t.created_at
FROM cog.turns t;

CREATE OR REPLACE VIEW lat.cell_phi AS
SELECT
  c.cell_id, c.space, c.level, c.radial_index,
  c.centroid, c.radius, c.spiral_angle, c.radial_distance,
  (SELECT value_real FROM lat.config WHERE key='golden_ratio_phi') AS phi,
  power((SELECT value_real FROM lat.config WHERE key='golden_ratio_phi'), c.radial_index) AS phi_pow_r
FROM lat.cells c;

-- Tunables for S
INSERT INTO lat.config (key, value_real, description) VALUES
('S_w_chunk',  0.34, 'weight of chunk density into S'),
('S_w_sense',  0.33, 'weight of sense support into S'),
('S_w_memory', 0.33, 'weight of memory strength into S')
ON CONFLICT (key) DO UPDATE SET value_real = EXCLUDED.value_real, description = EXCLUDED.description;

CREATE OR REPLACE VIEW lat._cfg AS
SELECT
  (SELECT value_real FROM lat.config WHERE key='S_w_chunk')  AS w_chunk,
  (SELECT value_real FROM lat.config WHERE key='S_w_sense')  AS w_sense,
  (SELECT value_real FROM lat.config WHERE key='S_w_memory') AS w_memory;

-- Source energy S per sense (simple, explainable)
CREATE OR REPLACE VIEW lat.sense_energy AS
WITH cfg AS (SELECT * FROM lat._cfg),
inst AS (
  SELECT s.sense_id,
         count(*)::float AS n_inst,
         avg(least(greatest(ch.token_count,0), 4096))::float AS avg_tokens
  FROM token.senses s
  LEFT JOIN token.instances i ON i.sense_id=s.sense_id
  LEFT JOIN content.chunks ch ON ch.chunk_id=i.chunk_id
  GROUP BY s.sense_id
),
mem AS (
  SELECT e.src_id AS sense_id, avg(m.strength)::float AS avg_mem_strength
  FROM lat.edges e
  JOIN cog.memories m ON (e.dst_kind='memory' AND e.dst_id=m.mem_id)
  WHERE e.src_kind='sense'
  GROUP BY e.src_id
)
SELECT
  s.sense_id,
  coalesce(inst.n_inst,0)                        AS n_inst,
  coalesce(inst.avg_tokens,0)                    AS avg_tokens,
  coalesce(mem.avg_mem_strength,0)               AS avg_mem_strength,
  (1 - exp(-coalesce(inst.n_inst,0)/10.0))       AS n_inst_nz,
  least(coalesce(inst.avg_tokens,0)/2048.0, 1.0) AS tokens_nz,
  least(coalesce(mem.avg_mem_strength,0), 1.0)   AS mem_nz,
  (SELECT w_chunk FROM cfg)  * least(coalesce(inst.avg_tokens,0)/2048.0, 1.0) +
  (SELECT w_sense FROM cfg)  * (1 - exp(-coalesce(inst.n_inst,0)/10.0)) +
  (SELECT w_memory FROM cfg) * least(coalesce(mem.avg_mem_strength,0), 1.0) AS S
FROM token.senses s
LEFT JOIN inst USING (sense_id)
LEFT JOIN mem  USING (sense_id);

-- Unified edge influence score (structure + recency + source energy)
CREATE OR REPLACE VIEW lat.edge_influence AS
WITH a_recent AS (
  SELECT kind, node_id, sum(strength) AS act24
  FROM lat.activations
  WHERE created_at > now() - interval '24 hours'
  GROUP BY 1,2
),
sense_S AS (SELECT sense_id, S FROM lat.sense_energy),
end_S AS (
  SELECT e.src_kind, e.src_id,
         CASE WHEN e.src_kind='sense' THEN s.S ELSE NULL END AS S_src
  FROM lat.edges e
  LEFT JOIN sense_S s ON (e.src_kind='sense' AND e.src_id=s.sense_id)
),
dst_S AS (
  SELECT e.dst_kind, e.dst_id,
         CASE WHEN e.dst_kind='sense' THEN s.S ELSE NULL END AS S_dst
  FROM lat.edges e
  LEFT JOIN sense_S s ON (e.dst_kind='sense' AND e.dst_id=s.sense_id)
)
SELECT
  e.*,
  coalesce(a1.act24,0) AS src_act24,
  coalesce(a2.act24,0) AS dst_act24,
  coalesce(es.S_src,0) AS S_src,
  coalesce(ds.S_dst,0) AS S_dst,
  (e.weight*0.6) + (least(coalesce(a1.act24,0) + coalesce(a2.act24,0), 10)/10.0)*0.2 +
  (least(coalesce(es.S_src,0)+coalesce(ds.S_dst,0),2)/2.0)*0.2 AS influence
FROM lat.edges e
LEFT JOIN a_recent a1 ON a1.kind=e.src_kind AND a1.node_id=e.src_id
LEFT JOIN a_recent a2 ON a2.kind=e.dst_kind AND a2.node_id=e.dst_id
LEFT JOIN end_S es    ON es.src_kind=e.src_kind AND es.src_id=e.src_id
LEFT JOIN dst_S ds    ON ds.dst_kind=e.dst_kind AND ds.dst_id=e.dst_id;

-- =========================================================
-- HYGIENE: cleanup edges/activations on delete (no FKs possible)
-- =========================================================
CREATE OR REPLACE FUNCTION lat._del_edges_for(kind lat.node_kind, id BIGINT)
RETURNS void LANGUAGE sql AS $$
  DELETE FROM lat.edges WHERE (src_kind=kind AND src_id=id) OR (dst_kind=kind AND dst_id=id);
$$;

CREATE OR REPLACE FUNCTION lat._del_acts_for(kind lat.node_kind, id BIGINT)
RETURNS void LANGUAGE sql AS $$
  DELETE FROM lat.activations WHERE kind=kind AND node_id=id;
$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_form() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('form',   OLD.form_id);
  PERFORM lat._del_acts_for('form',    OLD.form_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_sense() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('sense',  OLD.sense_id);
  PERFORM lat._del_acts_for('sense',   OLD.sense_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_chunk() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('chunk',  OLD.chunk_id);
  PERFORM lat._del_acts_for('chunk',   OLD.chunk_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_memory() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('memory', OLD.mem_id);
  PERFORM lat._del_acts_for('memory',  OLD.mem_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_turn() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('turn',   OLD.turn_id);
  PERFORM lat._del_acts_for('turn',    OLD.turn_id);
  RETURN NULL;
END$$;

CREATE OR REPLACE FUNCTION lat._cleanup_after_doc() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
  PERFORM lat._del_edges_for('doc',    OLD.doc_id);
  PERFORM lat._del_acts_for('doc',     OLD.doc_id);
  RETURN NULL;
END$$;

-- Attach triggers (idempotent guard via pg_trigger)
DO $$
BEGIN
  IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = '_lat_cleanup_form') THEN
    CREATE TRIGGER _lat_cleanup_form   AFTER DELETE ON token.forms       FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_form();
  END IF;
  IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = '_lat_cleanup_sense') THEN
    CREATE TRIGGER _lat_cleanup_sense  AFTER DELETE ON token.senses      FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_sense();
  END IF;
  IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = '_lat_cleanup_chunk') THEN
    CREATE TRIGGER _lat_cleanup_chunk  AFTER DELETE ON content.chunks    FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_chunk();
  END IF;
  IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = '_lat_cleanup_mem') THEN
    CREATE TRIGGER _lat_cleanup_mem    AFTER DELETE ON cog.memories      FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_memory();
  END IF;
  IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = '_lat_cleanup_turn') THEN
    CREATE TRIGGER _lat_cleanup_turn   AFTER DELETE ON cog.turns         FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_turn();
  END IF;
  IF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = '_lat_cleanup_doc') THEN
    CREATE TRIGGER _lat_cleanup_doc    AFTER DELETE ON content.documents FOR EACH ROW EXECUTE FUNCTION lat._cleanup_after_doc();
  END IF;
END$$;

-- =========================================================
-- (Optional) Partitioning starter (uncomment when needed)
-- =========================================================
-- -- Activations by month:
-- -- ALTER TABLE lat.activations PARTITION BY RANGE (created_at);
-- -- CREATE TABLE IF NOT EXISTS lat.activations_2025_09 PARTITION OF lat.activations
-- --   FOR VALUES FROM ('2025-09-01') TO ('2025-10-01');
-- -- Edges by relation:
-- -- ALTER TABLE lat.edges PARTITION BY LIST (rel);
-- -- CREATE TABLE IF NOT EXISTS lat.edges_cooccurs PARTITION OF lat.edges FOR VALUES IN ('cooccurs');
-- -- CREATE TABLE IF NOT EXISTS lat.edges_flow     PARTITION OF lat.edges FOR VALUES IN ('initiates','stabilizes','closes');

If you want, I can also give you a tiny SQL smoke-test snippet to run right after applying this (checks HNSW use, creates a couple rows, queries lat.cell_phi, lat.sense_energy, and lat.edge_influence).

Here’s a tight blurb you can drop on the site:

What this is.
TokenSpace is a database schema for storing and navigating meaning—not just documents. It combines four layers: content (docs/chunks + embeddings), token (words/forms with learned senses and real text instances), cognition (conversations, reflections, memories), and a lattice that links everything together with typed edges, multi-scale clusters (“cells”), neighbor caches, and lightweight dynamics (activations, decay/reinforcement). Configurable constants (e.g., the golden ratio Φ) and optional spiral/toroidal coordinates let us overlay simple geometry on top of vector space. The aim is to mimic a living lattice: ideas organize themselves locally, form larger patterns over time, and strengthen or fade based on use—so the system can move from static storage to an evolving memory.

If you want a one-liner:
TokenSpace is a living, multi-scale knowledge lattice—built on vectors, graph edges, and gentle dynamics—that lets meaning organize and adapt over time.

Heck yes—let’s turn TokenSense into a tidy, shippable engine. Here’s a lean blueprint you can act on right away.

TokenSense: the engine layer

A. Processes (4 small scripts, one optional)

1) ingest.py (ETL)
– Pull raw sources → split → embed → write content.*
– Extract forms/instances → update token.*
– Optional edge seeding from citations/links → lat.edges(rel='refers_to'|'quotes')

2) lattice_maint.py (nightly)
– Decay + reinforcement (co-activations) → lat.edges.weight
– Refresh lat.neighbors (kNN) by space
– Re/cluster into lat.cells, update lat.memberships
– Maintain spiral_angle, radial_distance, radial_index
– Log to lat.topology_events

3) signals.py (near-real-time)
– On user events, append lat.activations(kind,node_id,strength,phase)
– (Optional) bump edges along the path just traversed
– Lightweight; can run as a small web worker or queue consumer

4) housekeeping.py (weekly)
– Vacuum/analyze hot tables, rotate partitions (if enabled)
– Prune very low-weight / stale edges
– Validate constraints (no orphan kinds/ids—triggers already help)

5) (optional) train_adapters.py
– Prepares training corpora, runs LoRA fine-tunes, registers new adapters (see D)

> Execution cadences: signals.py (continuous), ingest.py (on demand), lattice_maint.py (hourly or nightly), housekeeping.py (weekly).

B. Minimal configs each script reads

• DB DSN; embedding model name; LLM model name; top-k for neighbors; decay/alpha for reinforcement.
• Read constants from lat.config (Φ, k, weights for S, etc.)—we already added that table.

C. A few small schema nits to add (for models/adapters)

If you want to track which model made which vectors/answers and manage LoRA adapters, add:

-- Registry of base models (LLMs & embedders)
CREATE TABLE IF NOT EXISTS lat.model_registry (
  model_id   BIGSERIAL PRIMARY KEY,
  name       TEXT UNIQUE NOT NULL,   -- e.g., 'Qwen2.5-7B-Instruct', 'bge-m3', 'arctic-embed-l-v2'
  kind       TEXT NOT NULL CHECK (kind IN ('llm','embedder')),
  version    TEXT,
  context_len INT,
  meta       JSONB DEFAULT '{}'::jsonb,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- LoRA adapters tied to a base model
CREATE TABLE IF NOT EXISTS lat.lora_adapters (
  adapter_id BIGSERIAL PRIMARY KEY,
  base_model_id BIGINT NOT NULL REFERENCES lat.model_registry(model_id) ON DELETE CASCADE,
  name       TEXT NOT NULL,           -- e.g., 'ogs-sense-qa-v1'
  r          INT  NOT NULL,           -- rank
  alpha      INT  NOT NULL,
  target_modules TEXT[] NOT NULL,     -- e.g., '{q_proj,k_proj,v_proj,o_proj}'
  artifact_uri TEXT NOT NULL,         -- path to safetensors/peft dir
  metrics    JSONB DEFAULT '{}'::jsonb,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  UNIQUE (base_model_id, name)
);

-- Where each vector came from (so you can re-embed later)
ALTER TABLE IF NOT EXISTS content.chunks
  ADD COLUMN IF NOT EXISTS embed_model_id BIGINT REFERENCES lat.model_registry(model_id);

ALTER TABLE IF NOT EXISTS token.senses
  ADD COLUMN IF NOT EXISTS embed_model_id BIGINT REFERENCES lat.model_registry(model_id);

ALTER TABLE IF NOT EXISTS token.instances
  ADD COLUMN IF NOT EXISTS embed_model_id BIGINT REFERENCES lat.model_registry(model_id);

ALTER TABLE IF NOT EXISTS cog.turns
  ADD COLUMN IF NOT EXISTS embed_model_id BIGINT REFERENCES lat.model_registry(model_id);

That’s enough to:
– swap embedders cleanly,
– track which LoRA you used for a run,
– and re-index only what needs re-embedding.

D. Pick a 7B-class model (local-capable) + embeddings

Shortlist (all open-weights, strong 7B-ish picks)

• Qwen2.5-7B-Instruct — modern 7.6B, long context (reportedly up to 131k), good coding/math & multilingual; very active project. citeturn0search8turn0search2turn0search13
• Llama-3.1-8B-Instruct — slightly bigger than 7B but still “small”; 128k context, broad ecosystem/tooling, permissive license. citeturn0search3turn0search9turn0search14
• Mistral-7B-Instruct — lean & efficient; Apache-2.0; good latency and memory footprint. (Older than the two above but still a solid baseline.) citeturn0search4

My pick for you right now:
– If you want maximum context + multilingual at 7B size → Qwen2.5-7B-Instruct. citeturn0search8
– If you prefer the widest ecosystem and tooling → Llama-3.1-8B-Instruct (worth the extra 1B params). citeturn0search14

Embedding model (for VECTOR(1536))

• BGE-M3 — strong on retrieval; supports dense + multi-vector + sparse in one model; multilingual; up to ~8k tokens. Great for hybrid RAG. citeturn0search5turn0search11turn0search16
• Snowflake Arctic-Embed v2 (L/M sizes) — competitive MTEB-style performance; straightforward HF usage; enterprise-oriented. citeturn0search7turn0search18turn0search6turn0search0

My pick: start with BGE-M3 for flexibility (hybrid retrieval without extra plumbing). If you later need enterprise-grade consistency or want to A/B, add Arctic-Embed alongside it. citeturn0search11turn0search7

E. How LoRA fits operationally

• Inference: Your runtime selects {base model} + {optional LoRA adapter} by reading lat.model_registry and lat.lora_adapters.
• Training: train_adapters.py logs each run (dataset hash, r/alpha, metrics) and writes the artifact path.
• Routing: For certain domains (e.g., “TokenSense ops”), bind a LoRA by tag or by conversation to keep style/skills consistent.

No extra DB changes are necessary beyond the small tables above.

F. Tiny starter checklists

ingest.py
– [ ] Pull/convert → chunk (keep doc_id, seq)
– [ ] Embed via BGE-M3 → content.chunks.embedding, set embed_model_id
– [ ] Extract tokens/instances → token.*
– [ ] (Optional) Add lat.edges from links (rel='refers_to'|'quotes')

lattice_maint.py
– [ ] Decay lat.edges.weight *= 0.98
– [ ] Reinforce recent co-activations (+α)
– [ ] Recompute lat.neighbors (k=15) for chosen spaces
– [ ] Re/cluster → lat.cells + update spiral_angle, radial_distance, radial_index
– [ ] Append lat.topology_events

signals.py
– [ ] On query/click/answer → insert lat.activations (strength, phase)
– [ ] Optionally nudge along current path (small +weight)

housekeeping.py
– [ ] Vacuum/analyze hot tables
– [ ] Prune edges below epsilon weight
– [ ] Rotate/verify partitions (if enabled)

G. Next concrete steps

1) Register your picks:

INSERT INTO lat.model_registry(name,kind,version,context_len,meta)
VALUES
 ('Qwen2.5-7B-Instruct','llm','2.5',131072,'{}'),
 ('BAAI/bge-m3','embedder','1.0',8192,'{}')
ON CONFLICT (name) DO NOTHING;

2) Wire ingest.py to write embed_model_id appropriately.
3) Stand up the three maintenance scripts with simple .env settings.
4) (Optional) Train a first LoRA on your internal style; register it in lat.lora_adapters.

If you want, I can draft starter code skeletons for those three scripts (argparse + psycopg + HF pipelines) so you can drop them into your repo and fill in the project-specific bits.