@plur-ai/core 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,3 +1,13 @@
+import {
+  atomicWrite,
+  embeddingSearch,
+  engramSearchText,
+  ftsScore,
+  ftsTokenize,
+  getSyncStatus,
+  searchEngrams,
+  sync
+} from "./chunk-WPD4MPTT.js";
 import "./chunk-2ZDO52B4.js";
 
 // src/storage.ts
@@ -37,7 +47,8 @@ var PlurConfigSchema = z.object({
     spread_cap: z.number().default(3),
     spread_budget: z.number().default(480),
     co_access: z.boolean().default(true)
-  }).default({})
+  }).default({}),
+  allow_secrets: z.boolean().default(false)
 }).partial();
 
 // src/config.ts
@@ -146,7 +157,7 @@ var ExchangeMetadataSchema = z2.object({
 });
 var EngramSchema = z2.object({
   // Identity
-  id: z2.string().regex(/^(ENG|ABS)-[A-Za-z0-9-]+$/),
+  id: z2.string().regex(/^(ENG|ABS|META)-[A-Za-z0-9-]+$/),
   version: z2.number().int().min(1).default(2),
   status: z2.enum(["active", "dormant", "retired", "candidate"]),
   consolidated: z2.boolean().default(false),
@@ -196,7 +207,9 @@ var EngramSchema = z2.object({
   /** Exchange marketplace metadata: fitness, adoption, diversity. */
   exchange: ExchangeMetadataSchema.optional(),
   /** Extensible key-value data for domain-specific fields. */
-  structured_data: z2.record(z2.string(), z2.unknown()).optional()
+  structured_data: z2.record(z2.string(), z2.unknown()).optional(),
+  /** Polarity classification: 'do' for directives, 'dont' for prohibitions, null for unclassified. */
+  polarity: z2.enum(["do", "dont"]).nullable().default(null)
 });
 
 // src/schemas/pack.ts
@@ -243,168 +256,6 @@ var logger = {
   }
 };
 
-// src/sync.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync3, writeFileSync, renameSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, dirname } from "path";
-var GITIGNORE = `# PLUR \u2014 derived/cache files (regenerated automatically)
-embeddings/
-.embeddings-cache.json
-*.db
-*.sqlite
-exchange/
-`;
-function git(args, cwd) {
-  return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
-}
-function gitSafe(args, cwd) {
-  try {
-    return git(args, cwd);
-  } catch {
-    return null;
-  }
-}
-function isGitRepo(root) {
-  return existsSync3(join2(root, ".git"));
-}
-function hasGitCli() {
-  try {
-    execFileSync("git", ["--version"], { encoding: "utf8", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getRemote(root) {
-  return gitSafe(["remote", "get-url", "origin"], root);
-}
-function isDirty(root) {
-  const status = gitSafe(["status", "--porcelain"], root);
-  return status !== null && status.length > 0;
-}
-function countDiff(root, direction) {
-  const tracking = gitSafe(["rev-parse", "--abbrev-ref", "@{u}"], root);
-  if (!tracking) return 0;
-  const flag = direction === "ahead" ? "--left-only" : "--right-only";
-  const count = gitSafe(["rev-list", flag, "--count", "HEAD...@{u}"], root);
-  return count ? parseInt(count, 10) : 0;
-}
-function getSyncStatus(root) {
-  if (!isGitRepo(root)) {
-    return { initialized: false, remote: null, dirty: false, branch: null, ahead: 0, behind: 0 };
-  }
-  const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], root);
-  const remote = getRemote(root);
-  if (remote) gitSafe(["fetch", "origin", "--quiet"], root);
-  return {
-    initialized: true,
-    remote,
-    dirty: isDirty(root),
-    branch,
-    ahead: countDiff(root, "ahead"),
-    behind: countDiff(root, "behind")
-  };
-}
-function initRepo(root) {
-  git(["init"], root);
-  atomicWrite(join2(root, ".gitignore"), GITIGNORE);
-  git(["add", "-A"], root);
-  git(["commit", "-m", "Initial PLUR engram store"], root);
-}
-function commitChanges(root) {
-  if (!isDirty(root)) return 0;
-  git(["add", "-A"], root);
-  const diff = gitSafe(["diff", "--cached", "--stat", "--shortstat"], root);
-  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
-  git(["commit", "-m", `plur sync ${now}`], root);
-  const match = diff?.match(/(\d+) file/);
-  return match ? parseInt(match[1], 10) : 1;
-}
-function hasConflictMarkers(root) {
-  const result = gitSafe(["grep", "-l", "<<<<<<<"], root);
-  return result !== null && result.length > 0;
-}
-function pullRebase(root) {
-  const result = gitSafe(["pull", "--rebase", "origin", "main"], root);
-  if (result !== null) return true;
-  gitSafe(["rebase", "--abort"], root);
-  const mergeResult = gitSafe(["pull", "origin", "main", "--no-edit"], root);
-  if (mergeResult !== null) return true;
-  if (hasConflictMarkers(root)) {
-    gitSafe(["merge", "--abort"], root);
-    throw new Error("Sync conflict: YAML files have merge conflicts that require manual resolution. Your local changes are preserved.");
-  }
-  git(["add", "-A"], root);
-  gitSafe(["commit", "-m", "plur sync: merge conflict resolved (kept both)"], root);
-  return true;
-}
-function sync(root, remote) {
-  if (!hasGitCli()) {
-    throw new Error("git is not installed. Install git to enable sync.");
-  }
-  if (!isGitRepo(root)) {
-    initRepo(root);
-    if (remote) {
-      git(["remote", "add", "origin", remote], root);
-      const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
-      git(["push", "-u", "origin", branch], root);
-      return { action: "initialized", message: `Initialized and pushed to ${remote}`, remote, files_changed: 0 };
-    }
-    return {
-      action: "initialized",
-      message: "Initialized local git repo. Call plur.sync with remote to enable cross-device sync.",
-      remote: null,
-      files_changed: 0
-    };
-  }
-  const existingRemote = getRemote(root);
-  if (remote && !existingRemote) {
-    git(["remote", "add", "origin", remote], root);
-    const filesChanged2 = commitChanges(root);
-    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
-    git(["push", "-u", "origin", branch], root);
-    return { action: "synced", message: `Remote added and pushed to ${remote}`, remote, files_changed: filesChanged2 };
-  }
-  if (!existingRemote) {
-    const filesChanged2 = commitChanges(root);
-    if (filesChanged2 === 0) {
-      return { action: "up-to-date", message: 'No changes to commit. Add a remote with plur.sync({ remote: "..." }) to enable cross-device sync.', remote: null, files_changed: 0 };
-    }
-    return { action: "committed", message: `Committed ${filesChanged2} file(s) locally.`, remote: null, files_changed: filesChanged2 };
-  }
-  const filesChanged = commitChanges(root);
-  gitSafe(["fetch", "origin", "--quiet"], root);
-  const behind = countDiff(root, "behind");
-  const aheadBefore = countDiff(root, "ahead");
-  if (behind > 0) {
-    pullRebase(root);
-  }
-  const aheadAfter = countDiff(root, "ahead");
-  if (aheadAfter > 0) {
-    gitSafe(["push", "origin"], root);
-  }
-  if (filesChanged === 0 && behind === 0 && aheadBefore === 0) {
-    return { action: "up-to-date", message: "Already in sync.", remote: existingRemote, files_changed: 0 };
-  }
-  const parts = [];
-  if (filesChanged > 0) parts.push(`${filesChanged} file(s) committed`);
-  if (behind > 0) parts.push(`pulled ${behind} remote commit(s)`);
-  if (aheadAfter === 0 && aheadBefore > 0) parts.push("pushed");
-  return {
-    action: "synced",
-    message: `Synced. ${parts.join(", ")}.`,
-    remote: existingRemote,
-    files_changed: filesChanged
-  };
-}
-function atomicWrite(filePath, content) {
-  const dir = dirname(filePath);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-  const tmp = filePath + ".tmp";
-  writeFileSync(tmp, content);
-  renameSync(tmp, filePath);
-}
-
 // src/engrams.ts
 function loadEngrams(filePath) {
   if (!fs.existsSync(filePath)) return [];
@@ -475,68 +326,6 @@ function generateEngramId(existing) {
   return `${prefix}${String(next).padStart(3, "0")}`;
 }
 
-// src/fts.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "and",
-  "for",
-  "that",
-  "this",
-  "with",
-  "from",
-  "are",
-  "was",
-  "were",
-  "been",
-  "have",
-  "has",
-  "not",
-  "but",
-  "its",
-  "you",
-  "your",
-  "can",
-  "will",
-  "should",
-  "would",
-  "could",
-  "may",
-  "might"
-]);
-function ftsTokenize(text) {
-  return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).filter((w) => !STOP_WORDS.has(w));
-}
-function engramSearchText(engram) {
-  const parts = [engram.statement];
-  if (engram.domain) parts.push(engram.domain.replace(/\./g, " "));
-  if (engram.tags.length > 0) parts.push(engram.tags.join(" "));
-  if (engram.entities) {
-    for (const e of engram.entities) {
-      parts.push(e.name);
-      if (e.type !== "other") parts.push(e.type);
-    }
-  }
-  if (engram.temporal) {
-    if (engram.temporal.valid_from) parts.push(engram.temporal.valid_from);
-    if (engram.temporal.valid_until) parts.push(engram.temporal.valid_until);
-  }
-  if (engram.rationale) parts.push(engram.rationale);
-  return parts.join(" ");
-}
-function ftsScore(engram, queryTokens) {
-  const allTerms = ftsTokenize(engramSearchText(engram));
-  let matches = 0;
-  for (const qt of queryTokens) {
-    if (allTerms.some((t) => t.includes(qt) || qt.includes(t))) matches++;
-  }
-  return queryTokens.length > 0 ? matches / queryTokens.length : 0;
-}
-function searchEngrams(engrams, query, limit = 20) {
-  const queryTokens = ftsTokenize(query);
-  if (queryTokens.length === 0) return [];
-  return engrams.map((e) => ({ engram: e, score: ftsScore(e, queryTokens) })).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((r) => r.engram);
-}
-
 // src/decay.ts
 var DECAY_RATE = 0.05;
 var FLOOR = 0.05;
@@ -557,6 +346,53 @@ function decayedCoAccessStrength(strength, daysSinceUpdate, lambda = 0.01) {
   return floor + (strength - floor) * Math.exp(-lambda * daysSinceUpdate);
 }
 
+// src/polarity.ts
+var DONT_PATTERNS = [
+  /\bnever\b/i,
+  /\bdo\s+not\b/i,
+  /\bdon'?t\b/i,
+  /\bavoid\b/i,
+  /\bmust\s+not\b/i,
+  /\bshould\s+not\b/i,
+  /\bNOT\b.*?\b(?:include|use|run|start|create|add|send|describe|reference|assume)\b/,
+  /\bstop\b.*?\b(?:generating|iterating|doing|running|creating)\b/i
+];
+function classifyPolarity(statement) {
+  if (!statement || statement.length < 5) return null;
+  const dotIndex = statement.indexOf(".");
+  const firstSentence = statement.slice(0, dotIndex > 0 ? Math.min(dotIndex, 200) : 200);
+  for (const pattern of DONT_PATTERNS) {
+    if (pattern.test(firstSentence)) return "dont";
+  }
+  return null;
+}
+
+// src/confidence.ts
+function computeConfidence(input) {
+  const fb = input.feedback_signals ?? { positive: 0, negative: 0, neutral: 0 };
+  const total = fb.positive + fb.negative + fb.neutral;
+  if (total === 0) return 0.5;
+  const netRatio = (fb.positive - fb.negative) / total;
+  const dampening = 1 - 1 / (total + 1);
+  const adjustedRatio = netRatio * dampening;
+  const steepness = 2;
+  const base = 1 / (1 + Math.exp(-steepness * adjustedRatio));
+  const consolidationBonus = input.consolidated ? 0.05 : 0;
+  return Math.min(1, Math.max(0, base + consolidationBonus));
+}
+function computeMetaConfidence(evidenceCount, domainCount, structuralDepth, validationRatio) {
+  const evidenceSignal = Math.min(evidenceCount / 5, 1) * 0.25;
+  const domainSignal = Math.min(domainCount / 3, 1) * 0.35;
+  const depthSignal = Math.min(structuralDepth / 3, 1) * 0.2;
+  const validationSignal = validationRatio * 0.2;
+  return evidenceSignal + domainSignal + depthSignal + validationSignal;
+}
+function confidenceBand(score) {
+  if (score >= 0.7) return "high";
+  if (score >= 0.4) return "medium";
+  return "low";
+}
+
 // src/inject.ts
 var DEFAULT_MAX_TOKENS = 8e3;
 var DEFAULT_MIN_RELEVANCE = 0.3;
@@ -614,7 +450,7 @@ function stripAssociations(engram) {
 }
 function stripScoring(engram) {
   const { keyword_match: _, raw_score: _r, score: _s, ...rest } = engram;
-  return rest;
+  return { ...rest, confidence_score: computeConfidence(engram) };
 }
 function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilter, isPack) {
   if (scopeFilter) {
@@ -650,6 +486,8 @@ function scoreEngram(engram, promptLower, promptWords, packMatchTerms, scopeFilt
     else if (netFeedback < 0) score *= Math.max(1 + netFeedback * 0.1, 0.5);
   }
   if (engram.consolidated) score *= 1.1;
+  const emotionalWeight = engram.episodic?.emotional_weight ?? 5;
+  score *= 1 + (emotionalWeight - 5) * 0.04;
   return score;
 }
 function fillTokenBudget(scored, maxTokens) {
@@ -681,10 +519,13 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   const promptWords = new Set(promptLower.split(/\W+/).filter((w) => w.length > 2));
   const maxTokens = ctx.maxTokens ?? DEFAULT_MAX_TOKENS;
   const minRelevance = ctx.minRelevance ?? DEFAULT_MIN_RELEVANCE;
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const engramMap = /* @__PURE__ */ new Map();
   const scored = [];
   for (const engram of personalEngrams) {
     if (engram.status !== "active") continue;
+    if (engram.temporal?.valid_until && engram.temporal.valid_until < today) continue;
+    if (engram.temporal?.valid_from && engram.temporal.valid_from > today) continue;
     engramMap.set(engram.id, engram);
     let raw = scoreEngram(engram, promptLower, promptWords, [], ctx.scope, false);
     const embBoost = embeddingBoosts?.get(engram.id) ?? 0;
@@ -703,6 +544,8 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
     const matchTerms = packMeta.match_terms;
     for (const engram of pack.engrams) {
       if (engram.status !== "active") continue;
+      if (engram.temporal?.valid_until && engram.temporal.valid_until < today) continue;
+      if (engram.temporal?.valid_from && engram.temporal.valid_from > today) continue;
       engramMap.set(engram.id, engram);
       let raw = scoreEngram(engram, promptLower, promptWords, matchTerms, ctx.scope, true);
       const embBoost = embeddingBoosts?.get(engram.id) ?? 0;
@@ -750,6 +593,7 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   if (directives.length === 0 && dip19Pool.length === 0) {
     return {
       directives: [],
+      constraints: [],
       consider: [],
       tokens_used: { directives: 0, consider: 0 }
     };
@@ -787,18 +631,29 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
   const allConsider = [...dip19Pool, ...spreadCandidates];
   const agentDirectives = directives.map(stripAssociations);
   const agentConsider = allConsider.map(stripAssociations);
-  const wireDirectives = agentDirectives.map(stripScoring);
+  const wireAll = agentDirectives.map(stripScoring);
   const wireConsider = agentConsider.map(stripScoring);
+  const wireDirectives = [];
+  const wireConstraints = [];
+  for (const wire of wireAll) {
+    const polarity = wire.polarity ?? classifyPolarity(wire.statement);
+    if (polarity === "dont") {
+      wireConstraints.push(wire);
+    } else {
+      wireDirectives.push(wire);
+    }
+  }
   const considerTokens = dip19PoolTokens + spreadTokens;
   return {
     directives: wireDirectives,
+    constraints: wireConstraints,
     consider: wireConsider,
     tokens_used: { directives: directiveTokens, consider: considerTokens }
   };
 }
 
 // src/episodes.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import yaml3 from "js-yaml";
 function generateEpisodeId() {
   const ts = Date.now();
@@ -833,7 +688,7 @@ function queryTimeline(path2, query) {
   return episodes;
 }
 function loadEpisodes(path2) {
-  if (!existsSync5(path2)) return [];
+  if (!existsSync4(path2)) return [];
   try {
     const raw = yaml3.load(readFileSync3(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
@@ -905,86 +760,6 @@ Rules:
   }
 }
 
-// src/embeddings.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
-import { createHash } from "crypto";
-var embedPipeline = null;
-var transformersUnavailable = false;
-async function getEmbedder() {
-  if (transformersUnavailable) return null;
-  if (!embedPipeline) {
-    try {
-      const { pipeline } = await import("./transformers.node-PH5YK5EA.js");
-      embedPipeline = await pipeline("feature-extraction", "Xenova/bge-small-en-v1.5", {
-        dtype: "fp32"
-      });
-    } catch {
-      transformersUnavailable = true;
-      return null;
-    }
-  }
-  return embedPipeline;
-}
-async function embed(text) {
-  const embedder = await getEmbedder();
-  if (!embedder) return null;
-  const result = await embedder(text, { pooling: "cls", normalize: true });
-  return new Float32Array(result.data);
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
-  return dot;
-}
-function loadCache(cachePath) {
-  if (!existsSync6(cachePath)) return {};
-  try {
-    return JSON.parse(readFileSync4(cachePath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCache(cachePath, cache2) {
-  const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
-  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
-  atomicWrite(cachePath, JSON.stringify(cache2));
-}
-function hashStatement(statement) {
-  return createHash("sha256").update(statement).digest("hex").slice(0, 16);
-}
-async function embeddingSearch(engrams, query, limit, storagePath) {
-  if (engrams.length === 0) return [];
-  const cachePath = storagePath ? join3(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
-  const cache2 = loadCache(cachePath);
-  const queryEmbedding = await embed(query);
-  if (!queryEmbedding) {
-    return [];
-  }
-  const similarities = [];
-  for (const engram of engrams) {
-    const searchText = engramSearchText(engram);
-    const hash = hashStatement(searchText);
-    let engramEmbedding;
-    if (cache2[engram.id]?.hash === hash) {
-      engramEmbedding = new Float32Array(cache2[engram.id].embedding);
-    } else {
-      const emb = await embed(searchText);
-      if (!emb) return [];
-      engramEmbedding = emb;
-      cache2[engram.id] = {
-        hash,
-        embedding: Array.from(engramEmbedding)
-      };
-    }
-    const score = cosineSimilarity(queryEmbedding, engramEmbedding);
-    similarities.push({ engram, score });
-  }
-  saveCache(cachePath, cache2);
-  similarities.sort((a, b) => b.score - a.score);
-  return similarities.slice(0, limit).map((s) => s.engram);
-}
-
 // src/hybrid-search.ts
 function rrfMerge(resultSets, k = 60) {
   const scores = /* @__PURE__ */ new Map();
@@ -1183,6 +958,818 @@ ${manifest.description || ""}
   return { path: outputDir, engram_count: engrams.length };
 }
 
+// src/secrets.ts
+var SECRET_PATTERNS = [
+  { name: "aws_access_key", regex: /AKIA[0-9A-Z]{16}/ },
+  { name: "aws_secret_key", regex: /(?:aws_secret_access_key|secret_access_key)\s*[=:]\s*[A-Za-z0-9/+=]{40}/i },
+  { name: "generic_api_key", regex: /(?:^|[^a-z])(sk|pk)[-_][a-z0-9]{20,}/i },
+  { name: "api_key_assignment", regex: /(?:api[_-]?key|api[_-]?secret|secret[_-]?key)\s*[=:]\s*\S{20,}/i },
+  { name: "password_assignment", regex: /password\s*[=:]\s*\S{8,}/i },
+  { name: "connection_string", regex: /(?:postgres|mysql|mongodb|redis):\/\/\S+/ },
+  { name: "jwt", regex: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}/ },
+  { name: "private_key", regex: /-----BEGIN\s+\S+\s+PRIVATE KEY-----/ },
+  { name: "bearer_token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/ }
+];
+function detectSecrets(text) {
+  const matches = [];
+  for (const { name, regex } of SECRET_PATTERNS) {
+    const m = text.match(regex);
+    if (m) {
+      matches.push({ pattern: name, match: m[0].slice(0, 20) + "..." });
+    }
+  }
+  return matches;
+}
+
+// src/meta/sanitize.ts
+function sanitizeForPrompt(text) {
+  return text.replace(/```/g, "~~~").replace(/\n{3,}/g, "\n\n").replace(/^(system|assistant|user):/gim, "$1 -").slice(0, 2e3);
+}
+
+// src/meta/structural-analysis.ts
+var FAILURE_TAGS = /* @__PURE__ */ new Set(["correction", "mistake", "bug", "fix", "error", "wrong", "broken"]);
+var BATCH_SIZE = 5;
+function isFailureDriven(engram) {
+  if (engram.tags.some((t) => FAILURE_TAGS.has(t.toLowerCase()))) return true;
+  const fb = engram.feedback_signals;
+  if (fb && fb.negative > fb.positive) return true;
+  return false;
+}
+function prioritize(engrams) {
+  return [...engrams].sort((a, b) => {
+    const aFail = isFailureDriven(a) ? 0 : 1;
+    const bFail = isFailureDriven(b) ? 0 : 1;
+    if (aFail !== bFail) return aFail - bFail;
+    const aFb = a.feedback_signals?.negative ?? 0;
+    const bFb = b.feedback_signals?.negative ?? 0;
+    return bFb - aFb;
+  });
+}
+function buildPrompt(engrams) {
+  const items = engrams.map((e, i) => {
+    const parts = [`  Statement: "${sanitizeForPrompt(e.statement)}"`];
+    if (e.rationale) parts.push(`  Rationale: "${sanitizeForPrompt(e.rationale)}"`);
+    if (e.domain) parts.push(`  Domain: "${e.domain}"`);
+    return `Engram ${i + 1} (${e.id}):
+${parts.join("\n")}`;
+  }).join("\n\n");
+  return `Given these learned lessons, extract relational structure for cross-domain transfer.
+
+${items}
+
+For EACH engram, extract:
+1. The GOAL the agent had (abstract type, not domain-specific)
+2. Relational triples: subject (role + domain instance), predicate, object (role + domain instance), outcome
+3. Use domain-GENERAL role types (e.g., "safety-metric" not "liquidation-price")
+
+Return a JSON array with one object per engram:
+[{
+  "engram_id": "ENG-...",
+  "goal_context": "what the agent was trying to achieve (abstract)",
+  "triples": [{ "subject": { "role": "...", "domain_instance": "..." }, "predicate": "...", "object": { "role": "...", "domain_instance": "..." }, "outcome": "..." }]
+}]
+
+Rules:
+- Roles MUST be domain-general (e.g., "safety-metric" not "liquidation-price")
+- If a lesson is purely domain-specific with no transferable structure, return empty triples: []
+- Prefer causal chains over isolated attributes
+- Return ONLY valid JSON, no markdown fencing`;
+}
+async function analyzeStructure(engrams, llm) {
+  const prioritized = prioritize(engrams.filter((e) => e.status === "active"));
+  const results = [];
+  for (let i = 0; i < prioritized.length; i += BATCH_SIZE) {
+    const batch = prioritized.slice(i, i + BATCH_SIZE);
+    const prompt = buildPrompt(batch);
+    let parsed;
+    try {
+      const response = await llm(prompt);
+      const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+      parsed = JSON.parse(cleaned);
+    } catch {
+      try {
+        const retryResponse = await llm(prompt + "\n\nIMPORTANT: Return ONLY raw JSON array, no text.");
+        const cleaned = retryResponse.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+        parsed = JSON.parse(cleaned);
+      } catch {
+        continue;
+      }
+    }
+    for (const item of parsed) {
+      if (!item.triples || item.triples.length === 0) continue;
+      const engram = batch.find((e) => e.id === item.engram_id) ?? batch[parsed.indexOf(item)];
+      if (!engram) continue;
+      results.push({
+        engram_id: engram.id,
+        triples: item.triples,
+        goal_context: item.goal_context ?? "",
+        is_failure_driven: isFailureDriven(engram),
+        domain: engram.domain ?? "unknown",
+        polarity: classifyPolarity(engram.statement) === "dont" ? "dont" : "do"
+      });
+    }
+  }
+  return results;
+}
+
+// src/meta/similarity.ts
+function tokenSimilarity(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/[\s\[\]→+\-]+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/[\s\[\]→+\-]+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let overlap = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) overlap++;
+  }
+  return overlap / Math.sqrt(wordsA.size * wordsB.size);
+}
+
+// src/meta/clustering.ts
+function tripleToTemplate(triple) {
+  const parts = [triple.subject.role, triple.predicate, triple.object.role];
+  if (triple.outcome) parts.push("\u2192", triple.outcome);
+  return parts.join(" ");
+}
+function analysisTemplate(analysis) {
+  return analysis.triples.map(tripleToTemplate).join("; ");
+}
+async function computeSimilarityMatrix(templates) {
+  const n = templates.length;
+  const matrix = Array.from({ length: n }, () => Array(n).fill(0));
+  try {
+    const { embed, cosineSimilarity } = await import("./embeddings-Q76LNQ5B.js");
+    const embeddings = [];
+    for (const t of templates) {
+      embeddings.push(await embed(t));
+    }
+    if (embeddings[0] !== null) {
+      for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+          if (embeddings[i] && embeddings[j]) {
+            const sim = cosineSimilarity(embeddings[i], embeddings[j]);
+            matrix[i][j] = sim;
+            matrix[j][i] = sim;
+          }
+        }
+      }
+      return { matrix, method: "embedding" };
+    }
+  } catch {
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const sim = tokenSimilarity(templates[i], templates[j]);
+      matrix[i][j] = sim;
+      matrix[j][i] = sim;
+    }
+  }
+  return { matrix, method: "token" };
+}
+var EMBEDDING_THRESHOLD = 0.65;
+var TOKEN_THRESHOLD = 0.35;
+async function clusterByStructure(analyses, threshold2) {
+  if (analyses.length < 2) return [];
+  const templates = analyses.map((a) => analysisTemplate(a));
+  const { matrix, method } = await computeSimilarityMatrix(templates);
+  const effectiveThreshold = threshold2 ?? (method === "embedding" ? EMBEDDING_THRESHOLD : TOKEN_THRESHOLD);
+  const seenClusters = /* @__PURE__ */ new Set();
+  const clusters = [];
+  let clusterId = 0;
+  for (let i = 0; i < analyses.length; i++) {
+    const members = [analyses[i]];
+    const memberIndices = [i];
+    for (let j = 0; j < analyses.length; j++) {
+      if (j === i) continue;
+      if (matrix[i][j] >= effectiveThreshold) {
+        members.push(analyses[j]);
+        memberIndices.push(j);
+      }
+    }
+    if (members.length < 2) continue;
+    const memberKey = members.map((m) => m.engram_id).sort().join(",");
+    if (seenClusters.has(memberKey)) continue;
+    seenClusters.add(memberKey);
+    const domains = [...new Set(members.map((m) => m.domain))];
+    let totalSim = 0;
+    let pairs = 0;
+    for (let a = 0; a < memberIndices.length; a++) {
+      for (let b = a + 1; b < memberIndices.length; b++) {
+        totalSim += matrix[memberIndices[a]][memberIndices[b]];
+        pairs++;
+      }
+    }
+    clusters.push({
+      cluster_id: `cluster-${clusterId++}`,
+      members,
+      domains,
+      is_cross_domain: domains.length >= 2,
+      cohesion: pairs > 0 ? totalSim / pairs : 0
+    });
+  }
+  return clusters;
+}
+
+// src/meta/platitudes.ts
+var PLATITUDE_PATTERNS = [
+  "always be careful",
+  "verify before acting",
+  "plan ahead",
+  "consider edge cases",
+  "communicate clearly",
+  "test thoroughly",
+  "keep it simple",
+  "document your work",
+  "think before you act",
+  "double check"
+];
+function isPlatitude(statement) {
+  const lower = statement.toLowerCase();
+  return PLATITUDE_PATTERNS.some((p) => lower.includes(p)) || statement.length < 30;
+}
+
+// src/meta/alignment.ts
+async function alignCluster(cluster, llm) {
+  const tripleDescriptions = cluster.members.map((m) => {
+    const domain = sanitizeForPrompt(m.domain);
+    const triples = m.triples.map((t) => {
+      const parts = [`${sanitizeForPrompt(t.subject.role)} ${sanitizeForPrompt(t.predicate)} ${sanitizeForPrompt(t.object.role)}`];
+      if (t.outcome) parts.push(`\u2192 ${sanitizeForPrompt(t.outcome)}`);
+      return parts.join(" ");
+    }).join("; ");
+    return `Domain ${domain} (${m.engram_id}): ${triples}`;
+  }).join("\n");
+  const prompt = `These lessons come from different domains but may share a common structural principle:
+
+${tripleDescriptions}
+
+Tasks:
+1. Is there a genuine common relational structure? (Not surface similarity, not a platitude)
+2. Choose the structural frame that BEST captures the pattern:
+   - "goal-constraint-outcome": [goal] + [constraint] \u2192 [outcome]
+   - "feedback-loop": [action] \u2192 [effect] \u2192 [feeds back to action]
+   - "causal-chain": [A] causes [B] causes [C]
+   - "tradeoff": [optimizing X] at the expense of [Y]
+   - "recursive": [pattern] contains smaller instances of [same pattern]
+   - "freeform": describe the structure in your own terms
+3. Express the common structure using your chosen frame
+4. Rate structural depth (1-5): 1=surface, 3=causal chain, 5=deep systematic
+5. For each member, rate alignment (0-1) and explain the mapping in one sentence
+6. What does this structure PREDICT in a domain not listed above?
+
+Return JSON:
+{
+  "common_structure": {
+    "goal_type": "...",
+    "constraint_type": "...",
+    "outcome_type": "...",
+    "template": "...",
+    "structure_type": "goal-constraint-outcome" | "feedback-loop" | "causal-chain" | "tradeoff" | "recursive" | "freeform",
+    "freeform_structure": "..." (only if structure_type is "freeform")
+  } | null,
+  "structural_depth": N,
+  "member_alignments": [{ "engram_id": "...", "alignment_score": N, "mapping_rationale": "..." }],
+  "candidate_inferences": ["..."]
+}
+
+If the commonality is shallow or trivially obvious (e.g., "mistakes happen", "always be careful"), return null for common_structure. We prefer no extraction over a false abstraction.
+Return ONLY valid JSON, no markdown fencing.`;
+  try {
+    const response = await llm(prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    if (cleaned === "null" || cleaned === '{"common_structure": null}') return null;
+    const parsed = JSON.parse(cleaned);
+    if (!parsed.common_structure) return null;
+    if (parsed.structural_depth < 2) return null;
+    if (isPlatitude(parsed.common_structure.template)) return null;
+    if (parsed.common_structure.template.length < 30) return null;
+    const alignments = parsed.member_alignments ?? [];
+    const lowAlignments = alignments.filter((a) => a.alignment_score < 0.5);
+    if (lowAlignments.length > alignments.length / 2) return null;
+    return {
+      cluster_id: cluster.cluster_id,
+      common_structure: parsed.common_structure,
+      member_alignments: alignments,
+      structural_depth: parsed.structural_depth,
+      systematicity: parsed.structural_depth,
+      // Use depth as systematicity proxy
+      candidate_inferences: parsed.candidate_inferences ?? []
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/meta/formulation.ts
+var PIPELINE_VERSION = "1.0.0";
+function slugifyTemplate(template) {
+  return template.toLowerCase().replace(/[\[\]→+]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function isDuplicate(template, existingMetas) {
+  for (const meta of existingMetas) {
+    const metaField = meta.structured_data?.meta;
+    if (!metaField?.structure?.template) continue;
+    const sim = tokenSimilarity(template, metaField.structure.template);
+    if (sim > 0.9) return meta;
+  }
+  return null;
+}
+async function formulateMetaEngram(alignment, llm, existingMetas = [], domains = []) {
+  const { common_structure, member_alignments, structural_depth, candidate_inferences } = alignment;
+  if (isPlatitude(common_structure.template)) return null;
+  const memberSummary = member_alignments.map((m) => `  - ${m.engram_id}: ${sanitizeForPrompt(m.mapping_rationale)} (alignment: ${m.alignment_score})`).join("\n");
+  const prompt = `Structural principle: ${sanitizeForPrompt(common_structure.template)}
+Goal type: ${common_structure.goal_type}
+Constraint type: ${common_structure.constraint_type}
+Outcome type: ${common_structure.outcome_type}
+Structural depth: ${structural_depth}
+Evidence from members:
+${memberSummary}
+Candidate inferences: ${candidate_inferences.map(sanitizeForPrompt).join(", ")}
+
+Generate:
+1. A natural-language statement of this principle (1-2 sentences, precise, not generic)
+2. Conditions under which it holds (expected_conditions)
+3. Conditions under which it does NOT hold (expected_exceptions)
+4. A concrete test: pick a domain NOT in the evidence list, describe a scenario where this principle predicts a specific outcome (test_prediction)
+
+The statement must be specific enough to be FALSIFIABLE. If you cannot write falsification criteria, return null.
+
+Return JSON:
+{
+  "statement": "...",
+  "falsification": {
+    "expected_conditions": "...",
+    "expected_exceptions": "...",
+    "test_prediction": "..."
+  }
+}
+
+Or return null if the principle is too vague to falsify.
+Return ONLY valid JSON, no markdown fencing.`;
+  let parsed;
+  try {
+    const response = await llm(prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    if (cleaned === "null") return null;
+    parsed = JSON.parse(cleaned);
+  } catch {
+    return null;
+  }
+  if (!parsed || !parsed.statement || !parsed.falsification) return null;
+  if (!parsed.falsification.expected_conditions || !parsed.falsification.expected_exceptions) return null;
+  const duplicate = isDuplicate(common_structure.template, existingMetas);
+  if (duplicate) {
+    return null;
+  }
+  const evidenceCount = member_alignments.length;
+  const domainCount = domains.length > 0 ? domains.length : 1;
+  const validationRatio = 0;
+  const composite = computeMetaConfidence(evidenceCount, domainCount, structural_depth, validationRatio);
+  const slug = slugifyTemplate(common_structure.template);
+  const id = `META-${slug}`;
+  const evidence = member_alignments.map((ma) => ({
+    engram_id: ma.engram_id,
+    domain: "unknown",
+    // Will be enriched by pipeline orchestrator
+    mapping_rationale: ma.mapping_rationale,
+    alignment_score: ma.alignment_score
+  }));
+  const metaField = {
+    structure: common_structure,
+    evidence,
+    domain_coverage: {
+      validated: [],
+      failed: [],
+      predicted: candidate_inferences
+    },
+    falsification: parsed.falsification,
+    confidence: {
+      evidence_count: evidenceCount,
+      domain_count: domainCount,
+      structural_depth,
+      validation_ratio: validationRatio,
+      composite
+    },
+    hierarchy: {
+      level: domainCount >= 3 ? "top" : "mop",
+      parent: null,
+      children: []
+    },
+    pipeline_version: PIPELINE_VERSION
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const engram = {
+    id,
+    version: 2,
+    status: "active",
+    consolidated: false,
+    type: "behavioral",
+    scope: "global",
+    visibility: "private",
+    statement: parsed.statement,
+    domain: "meta",
+    tags: ["meta-engram", common_structure.goal_type, common_structure.constraint_type],
+    activation: {
+      retrieval_strength: composite,
+      storage_strength: 1,
+      frequency: 0,
+      last_accessed: now.slice(0, 10)
+    },
+    feedback_signals: { positive: 0, negative: 0, neutral: 0 },
+    knowledge_anchors: [],
+    associations: [],
+    derivation_count: evidenceCount,
+    pack: null,
+    abstract: null,
+    derived_from: null,
+    polarity: null,
+    knowledge_type: {
+      memory_class: "metacognitive",
+      cognitive_level: "evaluate"
+    },
+    structured_data: { meta: metaField }
+  };
+  return engram;
+}
+
+// src/meta/validation.ts
+async function validateMetaEngram(meta, testEngrams, testDomain, llm) {
+  const metaField = meta.structured_data?.meta;
+  if (!metaField) {
+    return {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: false,
+      matching_engram_id: null,
+      alignment_score: 0,
+      rationale: "Meta-engram has no meta field"
+    };
+  }
+  const template = metaField.structure.template;
+  const testEngramSummary = testEngrams.filter((e) => e.status === "active").slice(0, 10).map((e) => `  - [${e.id}] ${sanitizeForPrompt(e.statement)}`).join("\n");
+  if (!testEngramSummary) {
+    return {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: false,
+      matching_engram_id: null,
+      alignment_score: 0,
+      rationale: "No test engrams available for validation"
+    };
+  }
+  const prompt = `Meta-engram structural principle: ${sanitizeForPrompt(template)}
+Meta-engram statement: ${sanitizeForPrompt(meta.statement)}
+
+Test domain: ${testDomain}
+Test engrams from this domain:
+${testEngramSummary}
+
+Task: Does any of the test engrams instantiate or validate this structural principle?
+
+If YES (a test engram matches):
+- prediction_held: true
+- matching_engram_id: the ID of the matching engram
+- alignment_score: 0.5-1.0 (how well the structural template maps)
+- rationale: one sentence explaining how the test engram maps to the template
+
+If NO (no test engram matches):
+- prediction_held: false
+- matching_engram_id: null
+- alignment_score: 0
+- rationale: one sentence explaining WHY none of the test engrams match (e.g., "Test engrams cover X domain but none exhibit the structural pattern of [assumed independence] \u2192 [understated risk]")
+
+Return JSON:
+{
+  "prediction_held": true|false,
+  "matching_engram_id": "ENG-..." | null,
+  "alignment_score": 0.0-1.0,
+  "rationale": "one sentence explanation \u2014 REQUIRED even when prediction_held is false"
+}
+
+Return ONLY valid JSON, no markdown fencing.`;
+  try {
+    const response = await llm(prompt);
+    const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const result = {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: Boolean(parsed.prediction_held),
+      matching_engram_id: parsed.matching_engram_id ?? null,
+      alignment_score: typeof parsed.alignment_score === "number" ? parsed.alignment_score : 0,
+      rationale: parsed.rationale ?? ""
+    };
+    if (result.prediction_held) {
+      if (!metaField.domain_coverage.validated.includes(testDomain)) {
+        metaField.domain_coverage.validated.push(testDomain);
+      }
+    } else {
+      if (!metaField.domain_coverage.failed.includes(testDomain)) {
+        metaField.domain_coverage.failed.push(testDomain);
+      }
+    }
+    const passes = metaField.domain_coverage.validated.length;
+    const total = passes + metaField.domain_coverage.failed.length;
+    const validationRatio = total > 0 ? passes / total : 0;
+    const updatedComposite = computeMetaConfidence(
+      metaField.confidence.evidence_count,
+      metaField.confidence.domain_count,
+      metaField.confidence.structural_depth,
+      validationRatio
+    );
+    metaField.confidence.validation_ratio = validationRatio;
+    metaField.confidence.composite = updatedComposite;
+    metaField.last_validated = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const failedCount = metaField.domain_coverage.failed.length;
+    if (failedCount >= 3) {
+      if (metaField.hierarchy.level === "top") {
+        metaField.hierarchy.level = "mop";
+      } else {
+        meta.status = "retired";
+      }
+    }
+    return result;
+  } catch {
+    return {
+      meta_engram_id: meta.id,
+      test_domain: testDomain,
+      prediction_held: false,
+      matching_engram_id: null,
+      alignment_score: 0,
+      rationale: "LLM parsing failed during validation"
+    };
+  }
+}
+
+// src/meta/hierarchy.ts
+var SUBSUMPTION_THRESHOLD = 0.75;
+function getMetaField(engram) {
+  return engram.structured_data?.meta ?? null;
+}
+function getDomainCount(metaField) {
+  const validated = metaField.domain_coverage.validated.length;
+  const evidenceDomains = new Set(metaField.evidence.map((e) => e.domain)).size;
+  return Math.max(validated, evidenceDomains, metaField.confidence.domain_count);
+}
+function organizeHierarchy(metaEngrams) {
+  const metas = metaEngrams.filter((e) => getMetaField(e) !== null && e.id.startsWith("META-"));
+  if (metas.length === 0) return metaEngrams;
+  for (const meta of metas) {
+    const mf = getMetaField(meta);
+    mf.hierarchy.parent = null;
+    mf.hierarchy.children = [];
+  }
+  for (let i = 0; i < metas.length; i++) {
+    for (let j = 0; j < metas.length; j++) {
+      if (i === j) continue;
+      const mfI = getMetaField(metas[i]);
+      const mfJ = getMetaField(metas[j]);
+      const sim = tokenSimilarity(mfI.structure.template, mfJ.structure.template);
+      if (sim < SUBSUMPTION_THRESHOLD) continue;
+      const domainsI = getDomainCount(mfI);
+      const domainsJ = getDomainCount(mfJ);
+      if (domainsI > domainsJ) {
+        if (!mfI.hierarchy.children.includes(metas[j].id)) {
+          mfI.hierarchy.children.push(metas[j].id);
+        }
+        if (!mfJ.hierarchy.parent) {
+          mfJ.hierarchy.parent = metas[i].id;
+        } else {
+          const currentParent = metas.find((m) => m.id === mfJ.hierarchy.parent);
+          const currentParentMf = currentParent ? getMetaField(currentParent) : null;
+          if (currentParentMf && getDomainCount(currentParentMf) < domainsI) {
+            mfJ.hierarchy.parent = metas[i].id;
+          }
+        }
+      }
+    }
+  }
+  for (const meta of metas) {
+    const mf = getMetaField(meta);
+    const domains = getDomainCount(mf);
+    if (domains >= 3 && !mf.hierarchy.parent) {
+      mf.hierarchy.level = "top";
+    } else {
+      mf.hierarchy.level = "mop";
+    }
+  }
+  return metaEngrams;
+}
+
+// src/meta/pipeline.ts
+async function extractMetaEngrams(engrams, llm, options = {}) {
+  const start = Date.now();
+  const {
+    run_validation = false,
+    validation_engrams = [],
+    existing_metas = [],
+    min_cluster_size = 2
+  } = options;
+  let rejected_as_platitudes = 0;
+  const analyses = await analyzeStructure(engrams, llm);
+  const clusters = await clusterByStructure(analyses);
+  const viableClusters = clusters.filter((c) => c.members.length >= min_cluster_size);
+  const alignmentResults = await Promise.all(
+    viableClusters.map((cluster) => alignCluster(cluster, llm))
+  );
+  const validAlignments = alignmentResults.filter((r) => r !== null);
+  const formulated = [];
+  for (const alignment of validAlignments) {
+    const cluster = viableClusters.find((c) => c.cluster_id === alignment.cluster_id);
+    const clusterDomains = cluster ? [...new Set(cluster.members.map((m) => m.domain))] : [];
+    const meta = await formulateMetaEngram(alignment, llm, [...existing_metas, ...formulated], clusterDomains);
+    if (meta === null) {
+      rejected_as_platitudes++;
+    } else {
+      if (cluster) {
+        const metaField = meta.structured_data?.meta;
+        if (metaField) {
+          const domainMap = new Map(cluster.members.map((m) => [m.engram_id, m.domain]));
+          for (const ev of metaField.evidence) {
+            if (domainMap.has(ev.engram_id)) {
+              ev.domain = domainMap.get(ev.engram_id);
+            }
+          }
+          metaField.domain_coverage.validated = clusterDomains;
+          meta.domain = clusterDomains.length >= 3 ? "meta" : `meta.${clusterDomains[0] ?? "unknown"}`;
+        }
+      }
+      formulated.push(meta);
+    }
+  }
+  const validationResults = [];
+  if (run_validation && validation_engrams.length > 0) {
+    for (const meta of formulated) {
+      const metaField = meta.structured_data?.meta;
+      if (!metaField) continue;
+      const evidenceDomains = new Set(metaField.evidence.map((e) => e.domain));
+      const testEngrams = validation_engrams.filter((e) => !evidenceDomains.has(e.domain ?? ""));
+      if (testEngrams.length > 0) {
+        const byDomain = /* @__PURE__ */ new Map();
+        for (const te of testEngrams) {
+          const d = te.domain ?? "unknown";
+          if (!byDomain.has(d)) byDomain.set(d, []);
+          byDomain.get(d).push(te);
+        }
+        for (const [domain, domainEngrams] of byDomain) {
+          const vr = await validateMetaEngram(meta, domainEngrams, domain, llm);
+          validationResults.push(vr);
+        }
+      }
+    }
+  }
+  const organized = organizeHierarchy(formulated);
+  const duration_ms = Date.now() - start;
+  return {
+    engrams_analyzed: analyses.length,
+    clusters_found: clusters.length,
+    alignments_passed: validAlignments.length,
+    meta_engrams_extracted: organized.length,
+    rejected_as_platitudes,
+    validation_results: validationResults,
+    results: organized,
+    duration_ms
+  };
+}
+
+// src/session-state.ts
+var SessionBreadcrumbs = class {
+  toolCalls = [];
+  engramsRecalled = [];
+  recordToolCall(tool, args) {
+    this.toolCalls.push({
+      tool,
+      args_keys: Object.keys(args).join(", "),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  recordEngramRecalled(engramId) {
+    if (!this.engramsRecalled.includes(engramId)) {
+      this.engramsRecalled.push(engramId);
+    }
+  }
+  getToolCalls() {
+    return this.toolCalls;
+  }
+  getEngramsRecalled() {
+    return this.engramsRecalled;
+  }
+  /**
+   * Returns only engram IDs that have the META- prefix.
+   * These represent meta-engrams injected into the session context.
+   */
+  getMetaEngramsRecalled() {
+    return this.engramsRecalled.filter((id) => id.startsWith("META-"));
+  }
+  generateContinuationContext() {
+    if (this.toolCalls.length === 0 && this.engramsRecalled.length === 0) return "";
+    const lines = [];
+    if (this.toolCalls.length > 0) {
+      const uniqueTools = [...new Set(this.toolCalls.map((tc) => tc.tool))];
+      lines.push(`Tools used: ${uniqueTools.join(", ")}`);
+      lines.push(`Total tool calls: ${this.toolCalls.length}`);
+    }
+    if (this.engramsRecalled.length > 0) {
+      lines.push(`Engrams recalled: ${this.engramsRecalled.length}`);
+      const metaCount = this.getMetaEngramsRecalled().length;
+      if (metaCount > 0) {
+        lines.push(`Meta-engrams: ${metaCount}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/guardrails.ts
+function generateGuardrails() {
+  return `## PLUR Memory Guardrails
+
+### Verification Protocol
+When recalling facts that will drive actions (server IPs, file paths, API endpoints, credential locations):
+1. State the recalled fact explicitly before acting on it
+2. Include the engram ID or search that produced it
+3. If no engram matches, say "No engram found \u2014 verifying from filesystem" and check directly
+4. Never interpolate between two engrams to produce a "probably correct" composite
+
+When the user corrects a recalled fact: call plur.learn immediately, then plur.feedback with negative signal on the wrong engram, before continuing the task.
+
+### Over-engineering Check
+Before proposing any new system, module, or architectural change:
+1. What is the simplest version that solves the actual problem?
+2. Is there an existing tool/pattern that already covers 80% of this?
+3. Will this create maintenance burden disproportionate to its value?
+
+If a task can be done in <20 lines of shell script, do that first.
+
+### Tool Selection Discipline
+Before invoking any external tool, apply the locality test:
+1. Is the answer already in engrams? \u2192 plur.recall
+2. Is the answer in the local filesystem? \u2192 Read/Grep/Glob
+3. Is the answer derivable from context already loaded? \u2192 Just answer
+4. Only if 1-3 fail \u2192 Use external tools
+
+Meta-engrams flagged as "[structural transfer \u2014 untested in current domain]" are hypotheses, not rules. Test before applying.`;
+}
+
+// src/schemas/meta-engram.ts
+import { z as z4 } from "zod";
+var StructuralTemplateSchema = z4.object({
+  goal_type: z4.string().min(1),
+  constraint_type: z4.string().min(1),
+  outcome_type: z4.string().min(1),
+  template: z4.string().min(1),
+  /** Structural frame — declares which relational pattern this meta-engram uses.
+   *  Allows flexible analogy beyond rigid [goal]+[constraint]->[outcome]. */
+  structure_type: z4.enum([
+    "goal-constraint-outcome",
+    "feedback-loop",
+    "causal-chain",
+    "recursive",
+    "tradeoff",
+    "freeform"
+  ]).default("goal-constraint-outcome"),
+  /** For patterns that don't fit the standard template fields — the LLM's own structural description */
+  freeform_structure: z4.string().optional()
+});
+var EvidenceEntrySchema = z4.object({
+  engram_id: z4.string(),
+  domain: z4.string(),
+  mapping_rationale: z4.string(),
+  alignment_score: z4.number().min(0).max(1)
+});
+var FalsificationSchema = z4.object({
+  expected_conditions: z4.string(),
+  expected_exceptions: z4.string(),
+  test_prediction: z4.string().optional()
+});
+var MetaConfidenceSchema = z4.object({
+  evidence_count: z4.number().int().min(0),
+  domain_count: z4.number().int().min(0),
+  structural_depth: z4.number().int().min(1).max(5),
+  validation_ratio: z4.number().min(0).max(1).default(0),
+  composite: z4.number().min(0).max(1)
+});
+var DomainCoverageSchema = z4.object({
+  validated: z4.array(z4.string()),
+  failed: z4.array(z4.string()).default([]),
+  predicted: z4.array(z4.string()).default([])
+});
+var HierarchyPositionSchema = z4.object({
+  level: z4.enum(["mop", "top"]),
+  parent: z4.string().nullable().default(null),
+  children: z4.array(z4.string()).default([])
+});
+var MetaFieldSchema = z4.object({
+  structure: StructuralTemplateSchema,
+  evidence: z4.array(EvidenceEntrySchema).min(2),
+  domain_coverage: DomainCoverageSchema,
+  falsification: FalsificationSchema,
+  confidence: MetaConfidenceSchema,
+  hierarchy: HierarchyPositionSchema,
+  pipeline_version: z4.string(),
+  last_validated: z4.string().optional()
+});
+
 // src/version-check.ts
 var cache = /* @__PURE__ */ new Map();
 async function checkForUpdate(packageName, currentVersion, onResult) {
@@ -1251,6 +1838,12 @@ var Plur = class {
   }
   /** Create engram, detect conflicts, save. Returns the created engram. */
   learn(statement, context) {
+    if (!this.config.allow_secrets) {
+      const secrets = detectSecrets(statement);
+      if (secrets.length > 0) {
+        throw new Error(`Secret detected in statement: ${secrets[0].pattern}. Use config.allow_secrets to override.`);
+      }
+    }
     const engrams = loadEngrams(this.paths.engrams);
     const id = generateEngramId(engrams);
     const scope = context?.scope ?? "global";
@@ -1282,6 +1875,7 @@ var Plur = class {
       pack: null,
       abstract: null,
       derived_from: null,
+      polarity: null,
       relations: conflictIds.length > 0 ? {
         broader: [],
         narrower: [],
@@ -1339,10 +1933,20 @@ var Plur = class {
     this._reactivateResults(results);
     return results;
   }
+  /** List all active engrams, optionally filtered by scope/domain. No search — returns all matches. */
+  list(options) {
+    return this._filterEngrams(options);
+  }
   /** Filter engrams by scope/domain/strength (shared by both modes) */
   _filterEngrams(options) {
     let engrams = loadEngrams(this.paths.engrams);
     engrams = engrams.filter((e) => e.status === "active");
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    engrams = engrams.filter((e) => {
+      if (e.temporal?.valid_until && e.temporal.valid_until < today) return false;
+      if (e.temporal?.valid_from && e.temporal.valid_from > today) return false;
+      return true;
+    });
     if (options?.domain) {
       engrams = engrams.filter((e) => e.domain?.startsWith(options.domain));
     }
@@ -1357,20 +1961,52 @@ var Plur = class {
     }
     return engrams;
   }
-  /** Reactivate accessed engrams (bump retrieval strength, frequency, last_accessed) */
+  /** Reactivate accessed engrams and update co-access associations */
   _reactivateResults(results) {
     if (results.length === 0) return;
     const allEngrams = loadEngrams(this.paths.engrams);
     const resultIds = new Set(results.map((e) => e.id));
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     let modified = false;
     for (const e of allEngrams) {
       if (resultIds.has(e.id)) {
         e.activation.retrieval_strength = reactivate(e.activation.retrieval_strength);
-        e.activation.last_accessed = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        e.activation.last_accessed = today;
         e.activation.frequency += 1;
         modified = true;
       }
     }
+    if (results.length >= 2 && this.config.injection?.co_access !== false) {
+      const topHalf = results.slice(0, Math.max(2, Math.ceil(results.length / 2)));
+      const topIds = topHalf.map((e) => e.id);
+      for (const sourceId of topIds) {
+        const source = allEngrams.find((e) => e.id === sourceId);
+        if (!source) continue;
+        for (const targetId of topIds) {
+          if (targetId === sourceId) continue;
+          const existing = source.associations.find(
+            (a) => a.type === "co_accessed" && a.target === targetId
+          );
+          if (existing) {
+            existing.strength = Math.min(0.95, existing.strength + 0.05);
+            existing.updated_at = today;
+            modified = true;
+          } else {
+            const coAccessCount = source.associations.filter((a) => a.type === "co_accessed").length;
+            if (coAccessCount < 5) {
+              source.associations.push({
+                target_type: "engram",
+                target: targetId,
+                type: "co_accessed",
+                strength: 0.3,
+                updated_at: today
+              });
+              modified = true;
+            }
+          }
+        }
+      }
+    }
     if (modified) saveEngrams(this.paths.engrams, allEngrams);
   }
   /** Scored injection within token budget (BM25 only). Returns formatted strings. */
@@ -1416,11 +2052,13 @@ var Plur = class {
       return wires.map((e) => `[${e.id}] ${e.statement}`).join("\n");
     };
     const directivesStr = formatEngrams(result.directives);
+    const constraintsStr = formatEngrams(result.constraints);
     const considerStr = formatEngrams(result.consider);
-    const count = result.directives.length + result.consider.length;
+    const count = result.directives.length + result.constraints.length + result.consider.length;
     const tokensUsed = result.tokens_used.directives + result.tokens_used.consider;
     return {
       directives: directivesStr,
+      constraints: constraintsStr,
       consider: considerStr,
       count,
       tokens_used: tokensUsed
@@ -1442,6 +2080,32 @@ var Plur = class {
     }
     saveEngrams(this.paths.engrams, engrams);
   }
+  /** Save extracted meta-engrams to the engram store. Skips IDs that already exist. */
+  saveMetaEngrams(metas) {
+    const engrams = loadEngrams(this.paths.engrams);
+    const existingIds = new Set(engrams.map((e) => e.id));
+    let saved = 0;
+    let skipped = 0;
+    for (const meta of metas) {
+      if (existingIds.has(meta.id)) {
+        skipped++;
+      } else {
+        engrams.push(meta);
+        saved++;
+      }
+    }
+    if (saved > 0) saveEngrams(this.paths.engrams, engrams);
+    return { saved, skipped };
+  }
+  /** Update an existing engram in the store by ID. Returns true if found and updated. */
+  updateEngram(updated) {
+    const engrams = loadEngrams(this.paths.engrams);
+    const idx = engrams.findIndex((e) => e.id === updated.id);
+    if (idx === -1) return false;
+    engrams[idx] = updated;
+    saveEngrams(this.paths.engrams, engrams);
+    return true;
+  }
   /** Set engram status to 'retired'. */
   forget(id, reason) {
     const engrams = loadEngrams(this.paths.engrams);
@@ -1472,6 +2136,7 @@ var Plur = class {
         const captured = match.slice(1).filter(Boolean).join(" ").trim();
         if (!captured || captured.length < 5) continue;
         if (seen.has(captured.toLowerCase())) continue;
+        if (!this.config.allow_secrets && detectSecrets(captured).length > 0) continue;
         seen.add(captured.toLowerCase());
         candidates.push({
           statement: captured,
@@ -1527,10 +2192,34 @@ var Plur = class {
   }
 };
 export {
+  DomainCoverageSchema,
+  EvidenceEntrySchema,
+  FalsificationSchema,
+  HierarchyPositionSchema,
+  MetaConfidenceSchema,
+  MetaFieldSchema,
+  PLATITUDE_PATTERNS,
   Plur,
+  SessionBreadcrumbs,
+  StructuralTemplateSchema,
+  alignCluster,
+  analyzeStructure,
   checkForUpdate,
+  classifyPolarity,
   clearVersionCache,
+  clusterByStructure,
+  computeConfidence,
+  computeMetaConfidence,
+  confidenceBand,
   detectPlurStorage,
+  detectSecrets,
   engramSearchText,
-  getCachedUpdateCheck
+  extractMetaEngrams,
+  formulateMetaEngram,
+  generateGuardrails,
+  getCachedUpdateCheck,
+  isPlatitude,
+  organizeHierarchy,
+  tokenSimilarity,
+  validateMetaEngram
 };