@agent-evolve/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1812 @@
+// intent/context-fill.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "we",
+  "with",
+  "you"
+]);
+function extractKeywords(userMsg) {
+  const matches = userMsg.toLowerCase().match(/[a-z0-9_-]+/g) ?? [];
+  return [...new Set(matches.filter((word) => word.length > 2 && !STOP_WORDS.has(word)))];
+}
+function resolveSource(entry) {
+  if (entry.data_type === "knowledge") {
+    return "knowledge";
+  }
+  if (entry.status === "rolled_back") {
+    return "memory(conflict)";
+  }
+  return "memory";
+}
+function dedup(results) {
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((result) => {
+    if (seen.has(result.id)) {
+      return false;
+    }
+    seen.add(result.id);
+    return true;
+  });
+}
+async function contextFill(userMsg, registry, agentConfig) {
+  const keywords = extractKeywords(userMsg);
+  return registry.search({
+    tags: keywords,
+    partition: agentConfig.readable_partitions,
+    minConfidence: 0.3,
+    limit: 20
+  }).map((result) => ({ ...result, source: resolveSource(result) }));
+}
+async function contextFillRefine(rough, initial, registry, agentConfig) {
+  const refined = registry.search({
+    tags: [rough.task_type, rough.domain, ...rough.key_entities],
+    partition: agentConfig.readable_partitions,
+    limit: 10
+  }).map((result) => ({ ...result, source: resolveSource(result) }));
+  return dedup([...initial, ...refined]);
+}
+
+// types/intent-object.ts
+var DEFAULT_ROUGH_INTENT = {
+  task_type: "unknown",
+  domain: "general",
+  complexity: "medium",
+  key_entities: [],
+  missing: []
+};
+
+// intent/rough-parse.ts
+var EXTRACTION_PROMPT = `
+After your response, output a JSON block (invisible to user):
+\`\`\`intent
+{"task_type":"...","domain":"...","complexity":"low|medium|high",
+"key_entities":["..."],"missing":["..."]}
+\`\`\``;
+function parseIntentBlock(response) {
+  const match = response.match(/```intent\n([\s\S]*?)\n```/);
+  if (!match?.[1]) {
+    return DEFAULT_ROUGH_INTENT;
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return DEFAULT_ROUGH_INTENT;
+  }
+}
+function stripIntentBlock(response) {
+  return response.replace(/```intent[\s\S]*?```/g, "").trim();
+}
+
+// intent/conflict-detect.ts
+var DEFAULT_PRIORITY_ORDER = [
+  "user_input",
+  "recent_pref",
+  "default",
+  "knowledge",
+  "memory",
+  "llm_extract",
+  "memory(conflict)"
+];
+function groupByField(fills) {
+  const groups = {};
+  for (const fill of fills) {
+    const field = fill.field ?? fill.data_type;
+    const existing = groups[field];
+    if (existing) {
+      existing.push(fill);
+    } else {
+      groups[field] = [fill];
+    }
+  }
+  return groups;
+}
+function isConflicting(a, b) {
+  if (!a.value || !b.value) return false;
+  return a.value.toLowerCase() !== b.value.toLowerCase();
+}
+function conflictDetect(fills, rules) {
+  const order = rules?.order ?? DEFAULT_PRIORITY_ORDER;
+  const byField = groupByField(fills);
+  const resolved = {};
+  const conflicts = [];
+  for (const [field, candidates] of Object.entries(byField)) {
+    if (candidates.length === 1) {
+      resolved[field] = candidates[0];
+      continue;
+    }
+    candidates.sort(
+      (a, b) => order.indexOf(a.source) - order.indexOf(b.source)
+    );
+    resolved[field] = candidates[0];
+    if (candidates.length >= 2 && isConflicting(candidates[0], candidates[1])) {
+      conflicts.push({ field, options: candidates.slice(0, 2) });
+    }
+  }
+  return { resolved, conflicts };
+}
+
+// intent/structure.ts
+function calcConfidence(rough, resolved) {
+  const unresolvedCount = rough.missing.length + resolved.conflicts.length;
+  const hasKnownType = rough.task_type !== "unknown";
+  const hasKnownDomain = rough.domain !== "general";
+  let confidence = 0.5;
+  if (hasKnownType) confidence += 0.2;
+  if (hasKnownDomain) confidence += 0.15;
+  if (Object.keys(resolved.resolved).length > 0) confidence += 0.1;
+  confidence -= unresolvedCount * 0.15;
+  return Math.max(0, Math.min(1, Number(confidence.toFixed(2))));
+}
+function extractConstraints(resolved) {
+  const constraints = [];
+  for (const [field, fill] of Object.entries(resolved.resolved)) {
+    if (fill.value && field.startsWith("constraint")) {
+      constraints.push(fill.value);
+    }
+  }
+  return constraints;
+}
+function toIntentSource(s) {
+  if (s === "recent_pref") return "user_input";
+  return s;
+}
+function buildSourceTrace(rough, resolved) {
+  const trace = {
+    task_type: "llm_extract",
+    domain: "llm_extract",
+    complexity: "llm_extract"
+  };
+  for (const [field, fill] of Object.entries(resolved.resolved)) {
+    trace[field] = toIntentSource(fill.source);
+  }
+  return trace;
+}
+function structure(rough, resolved, _userMsg) {
+  return {
+    task_type: rough.task_type,
+    domain: rough.domain,
+    complexity: resolved.resolved["complexity"]?.value ?? rough.complexity,
+    target_audience: resolved.resolved["target_audience"]?.value ?? "",
+    output_format: resolved.resolved["output_format"]?.value ?? "markdown",
+    style: resolved.resolved["style"]?.value ?? "",
+    key_entities: rough.key_entities,
+    constraints: extractConstraints(resolved),
+    confidence: calcConfidence(rough, resolved),
+    unresolved: [...rough.missing, ...resolved.conflicts.map((c) => c.field)],
+    source_trace: buildSourceTrace(rough, resolved)
+  };
+}
+
+// intent/confirm.ts
+var DEFAULT_THRESHOLD = { skip: 0.9, quick: 0.7 };
+function buildQuestions(intent) {
+  const questions = [];
+  for (const field of intent.unresolved) {
+    if (questions.length >= 2) break;
+    questions.push(`What should "${field}" be for this task?`);
+  }
+  if (questions.length === 0 && intent.confidence < 0.7) {
+    questions.push(`Can you clarify what you need? (detected: ${intent.task_type} in ${intent.domain})`);
+  }
+  return questions;
+}
+function updateIntent(intent, answers) {
+  const updated = { ...intent, unresolved: [...intent.unresolved] };
+  for (const [field, value] of Object.entries(answers)) {
+    if (field in updated) {
+      updated[field] = value;
+    }
+    updated.unresolved = updated.unresolved.filter((u) => u !== field);
+    updated.source_trace = { ...updated.source_trace, [field]: "user_input" };
+  }
+  updated.confidence = Math.min(1, intent.confidence + Object.keys(answers).length * 0.1);
+  return updated;
+}
+async function confirmIfNeeded(intent, adapter, threshold = DEFAULT_THRESHOLD) {
+  if (intent.confidence >= threshold.skip && intent.unresolved.length === 0) {
+    return intent;
+  }
+  if (intent.confidence >= threshold.quick) {
+    const ok = await adapter.sendConfirmation(intent);
+    if (ok) return intent;
+  }
+  const questions = buildQuestions(intent);
+  const answers = await adapter.askQuestions(questions);
+  return updateIntent(intent, answers);
+}
+
+// intent/pipeline.ts
+function buildTrace(rough, searchResults, refined, _resolved, confirmed) {
+  return {
+    id: `trace_${Math.random().toString(36).slice(2, 10)}`,
+    intent_id: `${confirmed.task_type}_${confirmed.domain}`,
+    query_tags: [rough.task_type, rough.domain, ...rough.key_entities],
+    partitions_searched: [...new Set(searchResults.map((r) => r.partition))],
+    hits: searchResults.map((r) => r.id),
+    loaded_l0: searchResults.map((r) => r.id),
+    promoted_l1: refined.map((r) => r.id),
+    promoted_l2: [],
+    injected: Object.values(_resolved.resolved).map((r) => r.id)
+  };
+}
+async function intentPipeline(userMsg, adapter, registry, agentConfig, config) {
+  const [roughIntent, searchResults] = await Promise.all([
+    Promise.resolve(adapter.parseIntentFromResponse(userMsg)),
+    contextFill(userMsg, registry, agentConfig)
+  ]);
+  const refined = await contextFillRefine(roughIntent, searchResults, registry, agentConfig);
+  const resolved = conflictDetect(refined, config.priorityRules);
+  const intent = structure(roughIntent, resolved, userMsg);
+  const confirmed = await confirmIfNeeded(intent, adapter, config.confirmThreshold);
+  const trace = buildTrace(roughIntent, searchResults, refined, resolved, confirmed);
+  registry.saveTrace(trace);
+  return {
+    intent: confirmed,
+    trace,
+    needsConfirmation: confirmed.confidence < config.confirmThreshold.skip
+  };
+}
+
+// intent/attention-control.ts
+var DEFAULT_ATTENTION_BUDGET = {
+  maxTokens: 4e3,
+  globalPrinciplesRatio: 0.15,
+  memoryRatio: 0.5,
+  skillDocsRatio: 0.35
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function scoreRelevance(item, intent) {
+  let score = item.confidence;
+  const entitySet = new Set(intent.key_entities.map((e) => e.toLowerCase()));
+  for (const tag of item.tags) {
+    if (entitySet.has(tag.toLowerCase())) score += 0.2;
+  }
+  if (item.data_type === "knowledge") score += 0.1;
+  if (item.status === "stale") score -= 0.3;
+  return Math.max(0, Math.min(1, score));
+}
+function selectAttentionSlots(fills, intent, globalPrinciples, skillDocs, budget = DEFAULT_ATTENTION_BUDGET) {
+  const slots = [];
+  let remainingTokens = budget.maxTokens;
+  const principlesBudget = Math.floor(budget.maxTokens * budget.globalPrinciplesRatio);
+  let principleTokens = 0;
+  for (const p of globalPrinciples) {
+    const tokens = estimateTokens(p);
+    if (principleTokens + tokens <= principlesBudget) {
+      slots.push({ category: "global_principle", content: p, relevanceScore: 1, tokenEstimate: tokens });
+      principleTokens += tokens;
+    }
+  }
+  remainingTokens -= principleTokens;
+  const memoryBudget = Math.floor(budget.maxTokens * budget.memoryRatio);
+  const scored = fills.map((f) => ({ fill: f, score: scoreRelevance(f, intent), tokens: estimateTokens(f.summary) })).sort((a, b) => b.score - a.score);
+  let memoryTokens = 0;
+  for (const { fill, score, tokens } of scored) {
+    if (memoryTokens + tokens > memoryBudget) continue;
+    slots.push({ category: "memory", content: fill.summary, relevanceScore: score, tokenEstimate: tokens });
+    memoryTokens += tokens;
+  }
+  remainingTokens -= memoryTokens;
+  const skillBudget = Math.min(Math.floor(budget.maxTokens * budget.skillDocsRatio), remainingTokens);
+  let skillTokens = 0;
+  for (const doc of skillDocs) {
+    const tokens = estimateTokens(doc);
+    if (skillTokens + tokens > skillBudget) continue;
+    slots.push({ category: "skill_doc", content: doc, relevanceScore: 0.8, tokenEstimate: tokens });
+    skillTokens += tokens;
+  }
+  return slots;
+}
+function assembleContext(slots) {
+  const sections = [];
+  const principles = slots.filter((s) => s.category === "global_principle");
+  if (principles.length > 0) {
+    sections.push("## Guidelines\n" + principles.map((s) => `- ${s.content}`).join("\n"));
+  }
+  const memories = slots.filter((s) => s.category === "memory");
+  if (memories.length > 0) {
+    sections.push("## Relevant Context\n" + memories.map((s) => `- ${s.content}`).join("\n"));
+  }
+  const skills = slots.filter((s) => s.category === "skill_doc");
+  if (skills.length > 0) {
+    sections.push("## Skill Reference\n" + skills.map((s) => s.content).join("\n\n"));
+  }
+  return sections.join("\n\n");
+}
+
+// registry/index-table.ts
+import Database from "better-sqlite3";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS registry (
+  id            TEXT PRIMARY KEY,
+  summary       TEXT NOT NULL,
+  tags          TEXT NOT NULL DEFAULT '[]',
+  storage_ptr   TEXT NOT NULL,
+  data_type     TEXT DEFAULT 'memory',
+  confidence    REAL DEFAULT 0.5,
+  verified_cnt  INTEGER DEFAULT 0,
+  partition     TEXT DEFAULT 'global',
+  source_agent  TEXT,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  last_accessed TEXT,
+  access_count  INTEGER DEFAULT 0,
+  status        TEXT DEFAULT 'active'
+);
+
+CREATE INDEX IF NOT EXISTS idx_tags ON registry(tags);
+CREATE INDEX IF NOT EXISTS idx_partition ON registry(partition);
+CREATE INDEX IF NOT EXISTS idx_data_type ON registry(data_type);
+CREATE INDEX IF NOT EXISTS idx_status ON registry(status);
+
+CREATE TABLE IF NOT EXISTS retrieval_traces (
+  id            TEXT PRIMARY KEY,
+  intent_id     TEXT,
+  query_tags    TEXT,
+  partitions_searched TEXT,
+  hits          TEXT,
+  loaded_l0     TEXT,
+  promoted_l1   TEXT,
+  promoted_l2   TEXT,
+  injected      TEXT,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS prediction_log (
+  id            TEXT PRIMARY KEY,
+  intent_id     TEXT,
+  task_type     TEXT,
+  dimension     TEXT,
+  estimated     REAL,
+  actual        REAL,
+  deviation     REAL,
+  level         TEXT,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS codec_table (
+  short_code    TEXT PRIMARY KEY,
+  full_value    TEXT NOT NULL,
+  usage_count   INTEGER DEFAULT 1,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+function randomId(prefix) {
+  return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function parseJsonArray(value) {
+  if (!value) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function normalizeRegistryRow(row) {
+  return {
+    ...row,
+    tags: parseJsonArray(row.tags)
+  };
+}
+function normalizeTraceRow(row) {
+  return {
+    id: row.id,
+    intent_id: row.intent_id ?? void 0,
+    query_tags: parseJsonArray(row.query_tags),
+    partitions_searched: parseJsonArray(row.partitions_searched),
+    hits: parseJsonArray(row.hits),
+    loaded_l0: parseJsonArray(row.loaded_l0),
+    promoted_l1: parseJsonArray(row.promoted_l1),
+    promoted_l2: parseJsonArray(row.promoted_l2),
+    injected: parseJsonArray(row.injected),
+    created_at: row.created_at
+  };
+}
+var IndexTable = class {
+  db;
+  constructor(dbPath = ":memory:") {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(SCHEMA_SQL);
+  }
+  insert(entry) {
+    const id = entry.id ?? randomId("reg");
+    const stmt = this.db.prepare(`
+      INSERT INTO registry (
+        id, summary, tags, storage_ptr, data_type, confidence, verified_cnt,
+        partition, source_agent, created_at, last_accessed, access_count, status
+      ) VALUES (
+        @id, @summary, @tags, @storage_ptr, @data_type, @confidence, @verified_cnt,
+        @partition, @source_agent, COALESCE(@created_at, datetime('now')),
+        @last_accessed, @access_count, @status
+      )
+    `);
+    stmt.run({
+      id,
+      summary: entry.summary,
+      tags: JSON.stringify(entry.tags ?? []),
+      storage_ptr: entry.storage_ptr,
+      data_type: entry.data_type ?? "memory",
+      confidence: entry.confidence ?? 0.5,
+      verified_cnt: entry.verified_cnt ?? 0,
+      partition: entry.partition ?? "global",
+      source_agent: entry.source_agent ?? null,
+      created_at: entry.created_at ?? null,
+      last_accessed: entry.last_accessed ?? null,
+      access_count: entry.access_count ?? 0,
+      status: entry.status ?? "active"
+    });
+    return id;
+  }
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM registry WHERE id = ?").get(id);
+    return row ? normalizeRegistryRow(row) : null;
+  }
+  update(id, updates) {
+    const current = this.get(id);
+    if (!current) {
+      return false;
+    }
+    const merged = {
+      ...current,
+      ...updates,
+      tags: updates.tags ?? current.tags
+    };
+    const stmt = this.db.prepare(`
+      UPDATE registry
+      SET summary = @summary,
+          tags = @tags,
+          storage_ptr = @storage_ptr,
+          data_type = @data_type,
+          confidence = @confidence,
+          verified_cnt = @verified_cnt,
+          partition = @partition,
+          source_agent = @source_agent,
+          created_at = @created_at,
+          last_accessed = @last_accessed,
+          access_count = @access_count,
+          status = @status
+      WHERE id = @id
+    `);
+    const { id: _ignoreId, ...rest } = merged;
+    const result = stmt.run({
+      ...rest,
+      id,
+      tags: JSON.stringify(merged.tags),
+      source_agent: merged.source_agent ?? null,
+      last_accessed: merged.last_accessed ?? null
+    });
+    return result.changes > 0;
+  }
+  delete(id) {
+    const result = this.db.prepare("DELETE FROM registry WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  search(filters = {}) {
+    const clauses = [];
+    const params = {};
+    if (filters.partition) {
+      const partitions = Array.isArray(filters.partition) ? filters.partition : [filters.partition];
+      clauses.push(`partition IN (${partitions.map((_, index) => `@partition${index}`).join(", ")})`);
+      partitions.forEach((partition, index) => {
+        params[`partition${index}`] = partition;
+      });
+    }
+    if (filters.dataType) {
+      const dataTypes = Array.isArray(filters.dataType) ? filters.dataType : [filters.dataType];
+      clauses.push(`data_type IN (${dataTypes.map((_, index) => `@dataType${index}`).join(", ")})`);
+      dataTypes.forEach((dataType, index) => {
+        params[`dataType${index}`] = dataType;
+      });
+    }
+    if (typeof filters.minConfidence === "number") {
+      clauses.push("confidence >= @minConfidence");
+      params.minConfidence = filters.minConfidence;
+    }
+    clauses.push(`status != 'rolled_back'`);
+    const limit = filters.limit ?? 20;
+    const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(
+      `
+          SELECT *
+          FROM registry
+          ${whereClause}
+          ORDER BY confidence DESC, verified_cnt DESC, created_at DESC
+          LIMIT @limit
+        `
+    ).all({ ...params, limit });
+    const normalized = rows.map(normalizeRegistryRow);
+    if (!filters.tags || filters.tags.length === 0) {
+      return normalized;
+    }
+    const tagSet = new Set(filters.tags.map((tag) => tag.toLowerCase()));
+    return normalized.filter(
+      (entry) => entry.tags.some((tag) => tagSet.has(tag.toLowerCase()))
+    );
+  }
+  recordAccess(id) {
+    const result = this.db.prepare(`
+      UPDATE registry
+      SET access_count = access_count + 1,
+          last_accessed = datetime('now')
+      WHERE id = ?
+    `).run(id);
+    return result.changes > 0;
+  }
+  saveTrace(trace) {
+    const id = trace.id ?? randomId("trace");
+    this.db.prepare(`
+      INSERT OR REPLACE INTO retrieval_traces (
+        id, intent_id, query_tags, partitions_searched, hits,
+        loaded_l0, promoted_l1, promoted_l2, injected, created_at
+      ) VALUES (
+        @id, @intent_id, @query_tags, @partitions_searched, @hits,
+        @loaded_l0, @promoted_l1, @promoted_l2, @injected,
+        COALESCE(@created_at, datetime('now'))
+      )
+    `).run({
+      id,
+      intent_id: trace.intent_id ?? null,
+      query_tags: JSON.stringify(trace.query_tags ?? []),
+      partitions_searched: JSON.stringify(trace.partitions_searched ?? []),
+      hits: JSON.stringify(trace.hits ?? []),
+      loaded_l0: JSON.stringify(trace.loaded_l0 ?? []),
+      promoted_l1: JSON.stringify(trace.promoted_l1 ?? []),
+      promoted_l2: JSON.stringify(trace.promoted_l2 ?? []),
+      injected: JSON.stringify(trace.injected ?? []),
+      created_at: trace.created_at ?? null
+    });
+    return id;
+  }
+  getTrace(id) {
+    const row = this.db.prepare("SELECT * FROM retrieval_traces WHERE id = ?").get(id);
+    return row ? normalizeTraceRow(row) : null;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// registry/auto-ingest.ts
+function extractTags(data) {
+  const tags = new Set(data.tags ?? []);
+  const words = data.content.toLowerCase().match(/[a-z0-9_-]+/g) ?? [];
+  for (const word of words) {
+    if (word.length > 3 && tags.size < 10) {
+      tags.add(word);
+    }
+  }
+  return [...tags];
+}
+function resolvePartition(sourceAgent) {
+  if (!sourceAgent) return "global";
+  return `agent_${sourceAgent.replace(/[^a-z0-9_-]/gi, "_")}`;
+}
+async function autoIngest(data, registry) {
+  const summary = data.content.slice(0, 200);
+  const tags = extractTags(data);
+  const partition = data.partition ?? resolvePartition(data.sourceAgent);
+  return registry.insert({
+    ...data.id ? { id: data.id } : {},
+    summary,
+    tags,
+    storage_ptr: data.storageLocation,
+    data_type: data.type,
+    partition,
+    source_agent: data.sourceAgent
+  });
+}
+
+// evaluate/deterministic.ts
+function verifyRegex(output, pattern) {
+  try {
+    return new RegExp(pattern).test(output);
+  } catch {
+    return false;
+  }
+}
+function verifyFieldPresence(output, fields) {
+  const lower = output.toLowerCase();
+  const present = [];
+  const missing = [];
+  for (const field of fields) {
+    if (lower.includes(field.toLowerCase())) {
+      present.push(field);
+    } else {
+      missing.push(field);
+    }
+  }
+  return { present, missing };
+}
+function verifyJsonSchema(output, fields) {
+  try {
+    const parsed = JSON.parse(output);
+    return fields.every((f) => f in parsed);
+  } catch {
+    return false;
+  }
+}
+function runVerification(output, rules) {
+  const checks = [];
+  for (const rule of rules) {
+    switch (rule.type) {
+      case "regex": {
+        const passed = verifyRegex(output, rule.pattern ?? "");
+        checks.push({ rule: `regex:${rule.pattern}`, passed, message: passed ? "Match found" : "No match" });
+        break;
+      }
+      case "field_presence": {
+        const { present, missing } = verifyFieldPresence(output, rule.fields ?? []);
+        const passed = missing.length === 0;
+        checks.push({ rule: "field_presence", passed, message: passed ? "All fields present" : `Missing: ${missing.join(", ")}` });
+        break;
+      }
+      case "json_schema": {
+        const passed = verifyJsonSchema(output, rule.fields ?? []);
+        checks.push({ rule: "json_schema", passed, message: passed ? "Valid schema" : "Schema mismatch" });
+        break;
+      }
+      case "custom": {
+        const passed = rule.validator ? rule.validator(output) : false;
+        checks.push({ rule: "custom", passed });
+        break;
+      }
+    }
+  }
+  const passedCount = checks.filter((c) => c.passed).length;
+  return {
+    passed: checks.every((c) => c.passed),
+    checks,
+    overallScore: checks.length > 0 ? passedCount / checks.length : 1
+  };
+}
+
+// evaluate/subdimension.ts
+function checkWordCount(min, max) {
+  return (output) => {
+    const count = output.split(/\s+/).length;
+    if (count >= min && count <= max) return 1;
+    if (count < min) return count / min;
+    return max / count;
+  };
+}
+function checkKeywordCoverage(keywords) {
+  return (output) => {
+    const lower = output.toLowerCase();
+    const found = keywords.filter((k) => lower.includes(k.toLowerCase()));
+    return keywords.length > 0 ? found.length / keywords.length : 1;
+  };
+}
+function checkFormatCompliance(expectedFormat) {
+  return (output) => {
+    switch (expectedFormat) {
+      case "markdown":
+        return output.includes("#") || output.includes("- ") ? 1 : 0.3;
+      case "json":
+        try {
+          JSON.parse(output);
+          return 1;
+        } catch {
+          return 0;
+        }
+      case "html":
+        return output.includes("<") && output.includes(">") ? 1 : 0.3;
+      default:
+        return 0.5;
+    }
+  };
+}
+function evaluate(output, template, agentScores, humanScores) {
+  const scores = [];
+  const needsHuman = [];
+  const needsAgent = [];
+  for (const dim of template.dimensions) {
+    if (dim.evaluator === "auto" && dim.autoCheck) {
+      scores.push({
+        dimension: dim.name,
+        score: dim.autoCheck(output),
+        evaluator: "auto"
+      });
+    } else if (dim.evaluator === "agent_review") {
+      const score = agentScores?.[dim.name];
+      if (score !== void 0) {
+        scores.push({ dimension: dim.name, score, evaluator: "agent_review" });
+      } else {
+        needsAgent.push(dim.name);
+        scores.push({ dimension: dim.name, score: 0, evaluator: "agent_review", feedback: "Pending agent review" });
+      }
+    } else {
+      const score = humanScores?.[dim.name];
+      if (score !== void 0) {
+        scores.push({ dimension: dim.name, score, evaluator: "human" });
+      } else {
+        needsHuman.push(dim.name);
+        scores.push({ dimension: dim.name, score: 0, evaluator: "human", feedback: "Pending human review" });
+      }
+    }
+  }
+  const totalWeight = template.dimensions.reduce((s, d) => s + d.weight, 0);
+  const overallScore = totalWeight > 0 ? template.dimensions.reduce((s, d, i) => s + d.weight * (scores[i]?.score ?? 0), 0) / totalWeight : 0;
+  return {
+    templateId: template.id,
+    scores,
+    overallScore: Number(overallScore.toFixed(3)),
+    needsHumanReview: needsHuman,
+    needsAgentReview: needsAgent
+  };
+}
+var TEMPLATES = {
+  copywriting: {
+    id: "tmpl-copywriting",
+    name: "Copywriting Evaluation",
+    taskTypes: ["email_copy", "social_media", "blog_post", "ad_copy", "web_copy", "press_release"],
+    dimensions: [
+      { name: "keyword_coverage", weight: 0.2, evaluator: "auto", autoCheck: checkKeywordCoverage([]) },
+      { name: "word_count", weight: 0.1, evaluator: "auto", autoCheck: checkWordCount(50, 2e3) },
+      { name: "format", weight: 0.1, evaluator: "auto", autoCheck: checkFormatCompliance("markdown") },
+      { name: "audience_fit", weight: 0.25, evaluator: "agent_review", description: "Does the tone match the target audience?" },
+      { name: "brand_consistency", weight: 0.15, evaluator: "agent_review", description: "Consistent with brand voice?" },
+      { name: "strategic_direction", weight: 0.2, evaluator: "human", description: "Aligns with business goals?" }
+    ]
+  },
+  code: {
+    id: "tmpl-code",
+    name: "Code Evaluation",
+    taskTypes: ["api_development", "feature", "bug_fix", "refactor"],
+    dimensions: [
+      { name: "syntax_valid", weight: 0.2, evaluator: "auto", autoCheck: (output) => output.includes("function") || output.includes("const") || output.includes("class") ? 1 : 0.3 },
+      { name: "format", weight: 0.1, evaluator: "auto", autoCheck: checkFormatCompliance("typescript") },
+      { name: "completeness", weight: 0.3, evaluator: "agent_review", description: "Covers all requirements?" },
+      { name: "code_quality", weight: 0.2, evaluator: "agent_review", description: "Clean, idiomatic code?" },
+      { name: "architecture", weight: 0.2, evaluator: "human", description: "Sound architectural decisions?" }
+    ]
+  },
+  research: {
+    id: "tmpl-research",
+    name: "Research Evaluation",
+    taskTypes: ["competitive_analysis", "market_research", "literature_review", "technical_research"],
+    dimensions: [
+      { name: "source_count", weight: 0.15, evaluator: "auto", autoCheck: (output) => {
+        const m = output.match(/https?:\/\//g);
+        return m ? Math.min(m.length / 5, 1) : 0;
+      } },
+      { name: "word_count", weight: 0.1, evaluator: "auto", autoCheck: checkWordCount(300, 5e3) },
+      { name: "depth", weight: 0.25, evaluator: "agent_review", description: "Sufficient analysis depth?" },
+      { name: "accuracy", weight: 0.25, evaluator: "agent_review", description: "Claims are factually correct?" },
+      { name: "actionability", weight: 0.25, evaluator: "human", description: "Provides actionable insights?" }
+    ]
+  },
+  data_analysis: {
+    id: "tmpl-data",
+    name: "Data Analysis Evaluation",
+    taskTypes: ["sales_analysis", "dashboard", "ab_test", "segmentation", "trend_analysis"],
+    dimensions: [
+      { name: "has_numbers", weight: 0.2, evaluator: "auto", autoCheck: (output) => /\d+(\.\d+)?%?/.test(output) ? 1 : 0 },
+      { name: "format", weight: 0.1, evaluator: "auto", autoCheck: checkFormatCompliance("markdown") },
+      { name: "methodology", weight: 0.3, evaluator: "agent_review", description: "Sound analytical methodology?" },
+      { name: "visualization", weight: 0.15, evaluator: "agent_review", description: "Appropriate data presentation?" },
+      { name: "business_relevance", weight: 0.25, evaluator: "human", description: "Answers the business question?" }
+    ]
+  }
+};
+
+// evaluate/prediction.ts
+function classifyDeviation(ratio) {
+  if (ratio <= 1.3) return { level: "normal", alpha: 0 };
+  if (ratio <= 2) return { level: "mild", alpha: 0.3 };
+  if (ratio > 2) return { level: "significant", alpha: 0.6 };
+  return { level: "normal", alpha: 0 };
+}
+function classifyReverseDeviation(ratio) {
+  if (ratio < 0.5) return { level: "reverse", alpha: 0.5 };
+  return { level: "normal", alpha: 0 };
+}
+function analyzeOneDimension(dimension, estimated, actual) {
+  if (estimated === 0) {
+    return { dimension, estimated, actual, ratio: actual > 0 ? Infinity : 1, level: "significant", alpha: 0.6, newEstimate: actual };
+  }
+  const ratio = actual / estimated;
+  let classification;
+  if (ratio < 1) {
+    classification = classifyReverseDeviation(ratio);
+  } else {
+    classification = classifyDeviation(ratio);
+  }
+  const newEstimate = classification.alpha > 0 ? estimated * (1 - classification.alpha) + actual * classification.alpha : estimated;
+  return {
+    dimension,
+    estimated,
+    actual,
+    ratio: Number(ratio.toFixed(3)),
+    level: classification.level,
+    alpha: classification.alpha,
+    newEstimate: Math.round(newEstimate)
+  };
+}
+function analyzePrediction(prediction, actual) {
+  const deviations = [];
+  const dims = [
+    { key: "tokens", name: "tokens" },
+    { key: "durationMs", name: "duration" },
+    { key: "steps", name: "steps" },
+    { key: "skillCount", name: "skill_count" }
+  ];
+  for (const { key, name } of dims) {
+    const est = prediction.estimates[key];
+    const act = actual[key];
+    if (est !== void 0 && act !== void 0) {
+      deviations.push(analyzeOneDimension(name, est, act));
+    }
+  }
+  const needsModelUpdate = deviations.some((d) => d.level === "significant" || d.level === "reverse");
+  return {
+    intentId: prediction.intentId,
+    taskType: prediction.taskType,
+    deviations,
+    needsModelUpdate
+  };
+}
+var DeviationAccumulator = class {
+  counts = /* @__PURE__ */ new Map();
+  record(taskType, dimension, level) {
+    if (level !== "mild") return false;
+    const key = `${taskType}:${dimension}`;
+    const count = (this.counts.get(key) ?? 0) + 1;
+    this.counts.set(key, count);
+    return count >= 3;
+  }
+  getCount(taskType, dimension) {
+    return this.counts.get(`${taskType}:${dimension}`) ?? 0;
+  }
+  reset(taskType, dimension) {
+    this.counts.delete(`${taskType}:${dimension}`);
+  }
+};
+
+// feedback/structured.ts
+var FEEDBACK_TEMPLATES = {
+  copywriting: {
+    id: "fb-copywriting",
+    taskType: "copywriting",
+    dimensions: [
+      { id: "tone", label: "Tone matches expectations?", type: "rating", scale: [1, 5] },
+      { id: "length", label: "Length appropriate?", type: "select", options: ["too_short", "just_right", "too_long"] },
+      { id: "accuracy", label: "Factually accurate?", type: "boolean" },
+      { id: "actionable", label: "Would you use this as-is?", type: "boolean" },
+      { id: "overall", label: "Overall quality", type: "rating", scale: [1, 5] }
+    ]
+  },
+  code: {
+    id: "fb-code",
+    taskType: "code",
+    dimensions: [
+      { id: "works", label: "Code runs correctly?", type: "boolean" },
+      { id: "complete", label: "Covers all requirements?", type: "rating", scale: [1, 5] },
+      { id: "quality", label: "Code quality", type: "rating", scale: [1, 5] },
+      { id: "approach", label: "Right approach?", type: "select", options: ["perfect", "acceptable", "wrong_approach"] },
+      { id: "overall", label: "Overall quality", type: "rating", scale: [1, 5] }
+    ]
+  },
+  research: {
+    id: "fb-research",
+    taskType: "research",
+    dimensions: [
+      { id: "depth", label: "Research depth", type: "rating", scale: [1, 5] },
+      { id: "accuracy", label: "Information accurate?", type: "boolean" },
+      { id: "coverage", label: "Covers the topic well?", type: "rating", scale: [1, 5] },
+      { id: "useful", label: "Findings are useful?", type: "boolean" },
+      { id: "overall", label: "Overall quality", type: "rating", scale: [1, 5] }
+    ]
+  },
+  general: {
+    id: "fb-general",
+    taskType: "general",
+    dimensions: [
+      { id: "understood", label: "Understood your intent?", type: "boolean" },
+      { id: "quality", label: "Output quality", type: "rating", scale: [1, 5] },
+      { id: "useful", label: "Result is useful?", type: "boolean" },
+      { id: "overall", label: "Overall satisfaction", type: "rating", scale: [1, 5] }
+    ]
+  }
+};
+function selectTemplate(taskType) {
+  if (taskType in FEEDBACK_TEMPLATES) return FEEDBACK_TEMPLATES[taskType];
+  const categoryMap = {
+    email_copy: "copywriting",
+    social_media: "copywriting",
+    blog_post: "copywriting",
+    ad_copy: "copywriting",
+    web_copy: "copywriting",
+    press_release: "copywriting",
+    api_development: "code",
+    feature: "code",
+    bug_fix: "code",
+    refactor: "code",
+    competitive_analysis: "research",
+    market_research: "research",
+    literature_review: "research"
+  };
+  const category = categoryMap[taskType];
+  if (category && category in FEEDBACK_TEMPLATES) return FEEDBACK_TEMPLATES[category];
+  return FEEDBACK_TEMPLATES["general"];
+}
+function normalizeFeedback(response, template) {
+  const normalized = {};
+  for (const dim of template.dimensions) {
+    const val = response.responses[dim.id];
+    if (val === void 0) continue;
+    if (dim.type === "boolean") {
+      normalized[dim.id] = val ? 1 : 0;
+    } else if (dim.type === "rating" && typeof val === "number") {
+      const [min, max] = dim.scale ?? [1, 5];
+      normalized[dim.id] = (val - min) / (max - min);
+    } else if (dim.type === "select" && typeof val === "string") {
+      const options = dim.options ?? [];
+      const idx = options.indexOf(val);
+      normalized[dim.id] = idx >= 0 ? idx / Math.max(1, options.length - 1) : 0.5;
+    }
+  }
+  return normalized;
+}
+function summarizeFeedback(responses, template) {
+  const allNormalized = responses.map((r) => normalizeFeedback(r, template));
+  const dims = template.dimensions.map((d) => d.id);
+  const averages = {};
+  for (const dim of dims) {
+    const values = allNormalized.map((n) => n[dim]).filter((v) => v !== void 0);
+    averages[dim] = values.length > 0 ? Number((values.reduce((a, b) => a + b, 0) / values.length).toFixed(3)) : 0;
+  }
+  const issues = Object.entries(averages).filter(([, v]) => v < 0.5).map(([k]) => k);
+  return {
+    taskType: template.taskType,
+    totalResponses: responses.length,
+    dimensionAverages: averages,
+    commonIssues: issues
+  };
+}
+
+// learn/attribution.ts
+function attributeIntentError(intent, groundTruth) {
+  const typeMatch = intent.task_type === groundTruth.task_type;
+  const domainMatch = intent.domain === groundTruth.domain;
+  if (typeMatch && domainMatch) return null;
+  return {
+    target: "intent_recognition",
+    confidence: typeMatch ? 0.5 : 0.85,
+    evidence: !typeMatch ? `task_type mismatch: got "${intent.task_type}", expected "${groundTruth.task_type}"` : `domain mismatch: got "${intent.domain}", expected "${groundTruth.domain}"`,
+    isHypothesis: typeMatch
+    // Domain-only mismatch is less certain
+  };
+}
+function attributeRetrievalError(trace, expectedHits) {
+  const hitSet = new Set(trace.hits);
+  const missed = expectedHits.filter((h) => !hitSet.has(h));
+  if (missed.length === 0) return null;
+  const missRate = missed.length / expectedHits.length;
+  return {
+    target: "memory_retrieval",
+    confidence: Math.min(0.9, 0.4 + missRate * 0.5),
+    evidence: `Missed ${missed.length}/${expectedHits.length} expected retrievals: ${missed.join(", ")}`,
+    isHypothesis: missRate < 0.5
+  };
+}
+function attributeOutputError(evaluation) {
+  const lowDims = evaluation.scores.filter((s) => s.score < 0.5);
+  if (lowDims.length === 0) return null;
+  return {
+    target: "output_quality",
+    confidence: Math.min(0.9, 0.3 + lowDims.length * 0.15),
+    evidence: `Low scores in: ${lowDims.map((d) => `${d.dimension}(${d.score})`).join(", ")}`,
+    isHypothesis: lowDims.length < 2
+  };
+}
+function analyzeAttribution(intent, trace, evaluation, groundTruth, expectedHits) {
+  const attributions = [];
+  if (groundTruth) {
+    const intentAttr = attributeIntentError(intent, groundTruth);
+    if (intentAttr) attributions.push(intentAttr);
+  }
+  if (expectedHits) {
+    const retrievalAttr = attributeRetrievalError(trace, expectedHits);
+    if (retrievalAttr) attributions.push(retrievalAttr);
+  }
+  const outputAttr = attributeOutputError(evaluation);
+  if (outputAttr) attributions.push(outputAttr);
+  attributions.sort((a, b) => b.confidence - a.confidence);
+  const primaryCause = attributions[0]?.target ?? "unknown";
+  const actionable = attributions.length > 0 && attributions[0].confidence >= 0.7;
+  return {
+    intentId: `${intent.task_type}_${intent.domain}`,
+    attributions,
+    primaryCause,
+    actionable
+  };
+}
+
+// learn/experience-router.ts
+function routeExperience(attribution, taskType, domain, sourceAgent) {
+  if (attribution.isHypothesis) {
+    return {
+      target: "memory",
+      partition: `agent_${sourceAgent}`,
+      reason: `Low confidence hypothesis (${attribution.confidence.toFixed(2)}), stored in agent memory for validation`
+    };
+  }
+  switch (attribution.target) {
+    case "intent_recognition":
+      return {
+        target: "knowledge_global",
+        partition: "global",
+        reason: "Intent recognition pattern applicable across agents"
+      };
+    case "skill_selection":
+      return {
+        target: "skill_doc",
+        partition: `skill_${taskType}`,
+        reason: `Skill-specific learning for ${taskType}`
+      };
+    case "memory_retrieval":
+      return {
+        target: "knowledge_dept",
+        partition: `dept_${domain}`,
+        reason: `Retrieval pattern specific to ${domain} domain`
+      };
+    case "output_quality":
+      return {
+        target: "skill_doc",
+        partition: `skill_${taskType}`,
+        reason: `Output quality improvement for ${taskType} tasks`
+      };
+    default:
+      return {
+        target: "memory",
+        partition: `agent_${sourceAgent}`,
+        reason: "Unknown attribution, stored in agent memory"
+      };
+  }
+}
+function createExperienceEntry(attribution, routing, taskType, domain, sourceAgent, traceId) {
+  return {
+    id: `exp_${Math.random().toString(36).slice(2, 10)}`,
+    summary: attribution.evidence.slice(0, 200),
+    condition: {
+      task_type: taskType,
+      domain
+    },
+    conclusion: `Issue: ${attribution.target}`,
+    action: attribution.evidence,
+    confidence: attribution.confidence,
+    source_agent: sourceAgent,
+    source_trace_id: traceId,
+    verified_count: 0,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: attribution.isHypothesis ? "hypothesis" : "active",
+    target: routing.target,
+    partition: routing.partition,
+    is_abstract: false
+  };
+}
+
+// learn/distill.ts
+function findDistillationCandidates(experiences, minGroupSize = 3) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const exp of experiences) {
+    if (exp.is_abstract || exp.status !== "active") continue;
+    const key = `${exp.condition.task_type ?? "unknown"}::${exp.conclusion}`;
+    const group = groups.get(key) ?? [];
+    group.push(exp);
+    groups.set(key, group);
+  }
+  const candidates = /* @__PURE__ */ new Map();
+  for (const [key, group] of groups) {
+    if (group.length >= minGroupSize) {
+      candidates.set(key, group);
+    }
+  }
+  return candidates;
+}
+function abstractify(conclusion, action) {
+  const absConclusion = conclusion.replace(/\d+(\.\d+)?(%| tokens?| chars?| words?| 字|字)/g, "[optimal value]").replace(/\d+/g, "[optimal value]").replace(/(中文|英文|Japanese|Chinese|English)/gi, "[language]").replace(/(社交媒体|email|slack|twitter|instagram)/gi, "[platform]");
+  const absAction = action.replace(/\d+(\.\d+)?(%| tokens?| chars?| words?| 字|字)/g, "[optimal value]").replace(/\d+/g, "[optimal value]").replace(/(中文|英文|Japanese|Chinese|English)/gi, "[language]").replace(/(社交媒体|email|slack|twitter|instagram)/gi, "[platform]");
+  return { conclusion: absConclusion, action: absAction };
+}
+function distillGroup(group) {
+  if (group.length === 0) return null;
+  const first = group[0];
+  const { conclusion, action } = abstractify(first.conclusion, first.action);
+  const abstractEntry = {
+    id: `abs_${Math.random().toString(36).slice(2, 10)}`,
+    summary: `Abstract: ${conclusion.slice(0, 150)}`,
+    condition: {
+      task_type: first.condition.task_type,
+      domain: first.condition.domain
+      // No environment — that's the point of abstraction
+    },
+    conclusion,
+    action,
+    confidence: Math.min(0.95, group.reduce((s, e) => s + e.confidence, 0) / group.length + 0.1),
+    source_agent: "distiller",
+    source_trace_id: group.map((e) => e.source_trace_id).join(","),
+    verified_count: group.length,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active",
+    target: "knowledge_global",
+    partition: "global",
+    abstracted_from: group.map((e) => e.id),
+    is_abstract: true
+  };
+  return {
+    abstractEntry,
+    sourceIds: group.map((e) => e.id),
+    pattern: `${first.condition.task_type}::${first.conclusion}`
+  };
+}
+function runDistillation(experiences, minGroupSize = 3) {
+  const candidates = findDistillationCandidates(experiences, minGroupSize);
+  const results = [];
+  for (const [, group] of candidates) {
+    const result = distillGroup(group);
+    if (result) results.push(result);
+  }
+  return results;
+}
+
+// learn/propagate.ts
+function publishToGlobal(experience) {
+  return {
+    experienceId: experience.id,
+    fromAgent: experience.source_agent,
+    toPartition: "global",
+    action: "publish",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function verifyExperience(experience, verifyingAgent) {
+  const updated = {
+    ...experience,
+    verified_count: experience.verified_count + 1,
+    confidence: Math.min(0.99, experience.confidence + 0.05)
+  };
+  return {
+    updated,
+    event: {
+      experienceId: experience.id,
+      fromAgent: verifyingAgent,
+      toPartition: experience.partition,
+      action: "verify",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function challengeExperience(experience, challengingAgent, evidence) {
+  const newConfidence = Math.max(0.1, experience.confidence - 0.15);
+  const updated = {
+    ...experience,
+    confidence: newConfidence,
+    status: newConfidence < 0.3 ? "hypothesis" : experience.status
+  };
+  return {
+    updated,
+    event: {
+      experienceId: experience.id,
+      fromAgent: challengingAgent,
+      toPartition: experience.partition,
+      action: "challenge",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function rankByReliability(experiences) {
+  return [...experiences].sort((a, b) => {
+    const scoreA = (a.verified_count + 1) * a.confidence;
+    const scoreB = (b.verified_count + 1) * b.confidence;
+    return scoreB - scoreA;
+  });
+}
+function filterPropagatable(experiences) {
+  return experiences.filter(
+    (e) => e.status === "active" && e.confidence >= 0.5 && e.verified_count >= 1
+  );
+}
+
+// learn/rollback.ts
+function checkPerformanceDegradation(window, degradationThreshold = 0.15) {
+  if (window.recentScores.length < 3) return false;
+  const diff = window.baselineAvg - window.currentAvg;
+  return diff > degradationThreshold;
+}
+function decideRollback(experience, window, threshold = 0.15) {
+  const shouldRollback = checkPerformanceDegradation(window, threshold);
+  const degradation = window.baselineAvg - window.currentAvg;
+  return {
+    shouldRollback,
+    experienceId: experience.id,
+    reason: shouldRollback ? `Performance dropped ${(degradation * 100).toFixed(1)}% after writing experience ${experience.id}` : "Performance stable",
+    baselineAvg: window.baselineAvg,
+    currentAvg: window.currentAvg,
+    degradation: Math.max(0, degradation)
+  };
+}
+function executeRollback(experience, relatedAbstracts = []) {
+  const rolledBack = {
+    ...experience,
+    status: "rolled_back"
+  };
+  const affectedAbstracts = relatedAbstracts.filter((a) => a.abstracted_from?.includes(experience.id)).map((a) => ({
+    ...a,
+    status: "hypothesis",
+    confidence: Math.max(0.1, a.confidence - 0.2)
+  }));
+  return { rolledBack, affectedAbstracts };
+}
+function buildPerformanceWindow(taskType, allScores, splitAt) {
+  const before = allScores.slice(0, splitAt);
+  const after = allScores.slice(splitAt);
+  const baselineAvg = before.length > 0 ? before.reduce((a, b) => a + b, 0) / before.length : 0.5;
+  const currentAvg = after.length > 0 ? after.reduce((a, b) => a + b, 0) / after.length : baselineAvg;
+  return {
+    taskType,
+    recentScores: after,
+    baselineAvg: Number(baselineAvg.toFixed(3)),
+    currentAvg: Number(currentAvg.toFixed(3))
+  };
+}
+
+// comm/codec.ts
+var Codec = class {
+  codeToValue = /* @__PURE__ */ new Map();
+  valueToCode = /* @__PURE__ */ new Map();
+  usageCounts = /* @__PURE__ */ new Map();
+  nextCodeId = 0;
+  autoRegisterThreshold;
+  constructor(options) {
+    this.autoRegisterThreshold = options?.autoRegisterThreshold ?? 3;
+  }
+  /**
+   * Register a short code for a frequently used value.
+   */
+  register(fullValue, shortCode) {
+    if (this.valueToCode.has(fullValue)) {
+      return this.valueToCode.get(fullValue);
+    }
+    const code = shortCode ?? `@${this.nextCodeId++}`;
+    this.codeToValue.set(code, fullValue);
+    this.valueToCode.set(fullValue, code);
+    this.usageCounts.set(code, 0);
+    return code;
+  }
+  /**
+   * Record usage of a value. Auto-registers after threshold.
+   * Returns short code if registered, undefined otherwise.
+   */
+  recordUsage(value) {
+    if (this.valueToCode.has(value)) {
+      const code = this.valueToCode.get(value);
+      this.usageCounts.set(code, (this.usageCounts.get(code) ?? 0) + 1);
+      return code;
+    }
+    const trackKey = `_pending:${value}`;
+    const count = (this.usageCounts.get(trackKey) ?? 0) + 1;
+    this.usageCounts.set(trackKey, count);
+    if (count >= this.autoRegisterThreshold) {
+      this.usageCounts.delete(trackKey);
+      return this.register(value);
+    }
+    return void 0;
+  }
+  /**
+   * Encode a message: replace registered full values with short codes.
+   */
+  encode(message) {
+    const encoded = {};
+    for (const [key, value] of Object.entries(message)) {
+      const code = this.valueToCode.get(value);
+      encoded[key] = code ?? value;
+    }
+    return encoded;
+  }
+  /**
+   * Decode a message: replace short codes with full values.
+   */
+  decode(message) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(message)) {
+      const full = this.codeToValue.get(value);
+      decoded[key] = full ?? value;
+    }
+    return decoded;
+  }
+  /**
+   * Get all registered entries for persistence.
+   */
+  getEntries() {
+    const entries = [];
+    for (const [code, value] of this.codeToValue) {
+      entries.push({
+        shortCode: code,
+        fullValue: value,
+        usageCount: this.usageCounts.get(code) ?? 0
+      });
+    }
+    return entries;
+  }
+  /**
+   * Load entries from persistence.
+   */
+  loadEntries(entries) {
+    for (const entry of entries) {
+      this.codeToValue.set(entry.shortCode, entry.fullValue);
+      this.valueToCode.set(entry.fullValue, entry.shortCode);
+      this.usageCounts.set(entry.shortCode, entry.usageCount);
+    }
+    const maxId = entries.map((e) => e.shortCode).filter((c) => c.startsWith("@")).map((c) => parseInt(c.slice(1), 10)).reduce((max, n) => Math.max(max, n + 1), this.nextCodeId);
+    this.nextCodeId = maxId;
+  }
+  /**
+   * Cleanup: remove low-frequency codes.
+   */
+  cleanup(minUsage = 2) {
+    let removed = 0;
+    for (const [code, count] of this.usageCounts) {
+      if (code.startsWith("_pending:")) continue;
+      if (count < minUsage) {
+        const value = this.codeToValue.get(code);
+        if (value) {
+          this.codeToValue.delete(code);
+          this.valueToCode.delete(value);
+          this.usageCounts.delete(code);
+          removed++;
+        }
+      }
+    }
+    return removed;
+  }
+};
+
+// ecosystem/template-market.ts
+var TemplateMarket = class {
+  templates = /* @__PURE__ */ new Map();
+  ratings = /* @__PURE__ */ new Map();
+  /**
+   * Submit a new template for review.
+   */
+  submit(submission) {
+    const id = submission.template.id;
+    this.templates.set(id, submission);
+    this.ratings.set(id, {
+      templateId: id,
+      usageCount: 0,
+      avgEffectiveness: 0,
+      upvotes: 0,
+      downvotes: 0
+    });
+    return id;
+  }
+  /**
+   * Approve a pending template.
+   */
+  approve(templateId) {
+    const sub = this.templates.get(templateId);
+    if (!sub || sub.status !== "pending") return false;
+    sub.status = "approved";
+    return true;
+  }
+  /**
+   * Reject a pending template.
+   */
+  reject(templateId) {
+    const sub = this.templates.get(templateId);
+    if (!sub || sub.status !== "pending") return false;
+    sub.status = "rejected";
+    return true;
+  }
+  /**
+   * Search templates by criteria.
+   */
+  search(query = {}) {
+    let results = [...this.templates.entries()].filter(([, s]) => s.status === "approved").map(([id, submission]) => ({
+      submission,
+      rating: this.ratings.get(id) ?? { templateId: id, usageCount: 0, avgEffectiveness: 0, upvotes: 0, downvotes: 0 }
+    }));
+    if (query.taskType) {
+      results = results.filter(
+        (r) => r.submission.template.taskTypes.includes(query.taskType)
+      );
+    }
+    if (query.minRating !== void 0) {
+      results = results.filter((r) => r.rating.avgEffectiveness >= query.minRating);
+    }
+    const sortBy = query.sortBy ?? "rating";
+    results.sort((a, b) => {
+      switch (sortBy) {
+        case "rating":
+          return b.rating.avgEffectiveness - a.rating.avgEffectiveness;
+        case "usage":
+          return b.rating.usageCount - a.rating.usageCount;
+        case "newest":
+          return b.submission.submittedAt.localeCompare(a.submission.submittedAt);
+        default:
+          return 0;
+      }
+    });
+    return results.slice(0, query.limit ?? 20);
+  }
+  /**
+   * Record a template usage and update effectiveness.
+   */
+  recordUsage(templateId, effectiveness) {
+    const rating = this.ratings.get(templateId);
+    if (!rating) return;
+    const total = rating.usageCount * rating.avgEffectiveness + effectiveness;
+    rating.usageCount++;
+    rating.avgEffectiveness = Number((total / rating.usageCount).toFixed(3));
+  }
+  /**
+   * Upvote a template.
+   */
+  upvote(templateId) {
+    const rating = this.ratings.get(templateId);
+    if (rating) rating.upvotes++;
+  }
+  /**
+   * Downvote a template.
+   */
+  downvote(templateId) {
+    const rating = this.ratings.get(templateId);
+    if (rating) rating.downvotes++;
+  }
+  /**
+   * Get a specific template by ID.
+   */
+  get(templateId) {
+    return this.templates.get(templateId);
+  }
+  /**
+   * Get rating for a template.
+   */
+  getRating(templateId) {
+    return this.ratings.get(templateId);
+  }
+  /**
+   * List all templates (including pending/rejected for admin).
+   */
+  listAll() {
+    return [...this.templates.values()];
+  }
+};
+
+// ecosystem/industry-packs.ts
+var MARKETING_PACK = {
+  id: "pack-marketing",
+  name: "Marketing & Advertising",
+  industry: "marketing",
+  description: "Brand tone guidelines, campaign templates, audience analysis frameworks",
+  knowledge: [
+    { summary: "Email subject lines perform best at 6-10 words", tags: ["email", "subject_line", "best_practice"], partition: "global" },
+    { summary: "Social media posts with images get 2.3x more engagement", tags: ["social_media", "engagement"], partition: "global" },
+    { summary: "CTA buttons in contrasting colors increase click-through by 21%", tags: ["cta", "conversion", "design"], partition: "global" },
+    { summary: "Personalized email campaigns have 29% higher open rates", tags: ["email", "personalization"], partition: "global" },
+    { summary: "Video content under 2 minutes has highest completion rate", tags: ["video", "content", "engagement"], partition: "global" }
+  ],
+  templates: [
+    {
+      id: "tmpl-campaign-brief",
+      name: "Campaign Brief Evaluation",
+      taskTypes: ["campaign_brief", "marketing_plan"],
+      dimensions: [
+        { name: "target_audience_clarity", weight: 0.25, evaluator: "auto", autoCheck: checkKeywordCoverage(["audience", "target", "demographic", "persona"]) },
+        { name: "kpi_defined", weight: 0.2, evaluator: "auto", autoCheck: checkKeywordCoverage(["kpi", "metric", "goal", "objective", "conversion"]) },
+        { name: "budget_mentioned", weight: 0.15, evaluator: "auto", autoCheck: checkKeywordCoverage(["budget", "cost", "spend", "investment"]) },
+        { name: "creative_direction", weight: 0.2, evaluator: "agent_review", description: "Clear creative direction?" },
+        { name: "strategic_alignment", weight: 0.2, evaluator: "human", description: "Aligns with brand strategy?" }
+      ]
+    }
+  ],
+  rules: [
+    { field: "tone", value: "engaging", source: "marketing_default" },
+    { field: "output_format", value: "markdown", source: "marketing_default" }
+  ]
+};
+var SOFTWARE_DEV_PACK = {
+  id: "pack-software",
+  name: "Software Development",
+  industry: "software",
+  description: "Code standards, CI/CD patterns, common pitfalls",
+  knowledge: [
+    { summary: "Always validate user input at API boundaries", tags: ["security", "api", "validation"], partition: "global" },
+    { summary: "Database queries should use parameterized statements to prevent SQL injection", tags: ["security", "database", "sql"], partition: "global" },
+    { summary: "Unit tests should cover edge cases: null, empty, boundary values", tags: ["testing", "best_practice"], partition: "global" },
+    { summary: "API endpoints should return consistent error response format", tags: ["api", "error_handling", "consistency"], partition: "global" },
+    { summary: "Use semantic versioning (semver) for all package releases", tags: ["versioning", "release", "npm"], partition: "global" },
+    { summary: "Git commit messages should follow conventional commits format", tags: ["git", "conventions"], partition: "global" }
+  ],
+  templates: [
+    {
+      id: "tmpl-code-review",
+      name: "Code Review Evaluation",
+      taskTypes: ["code_review", "pr_review"],
+      dimensions: [
+        { name: "security_check", weight: 0.2, evaluator: "auto", autoCheck: checkKeywordCoverage(["security", "vulnerability", "injection", "auth"]) },
+        { name: "test_coverage", weight: 0.2, evaluator: "auto", autoCheck: checkKeywordCoverage(["test", "coverage", "spec", "assert"]) },
+        { name: "error_handling", weight: 0.15, evaluator: "auto", autoCheck: checkKeywordCoverage(["error", "catch", "throw", "handle"]) },
+        { name: "code_clarity", weight: 0.25, evaluator: "agent_review", description: "Code is clear and well-documented?" },
+        { name: "architecture_fit", weight: 0.2, evaluator: "human", description: "Fits the overall architecture?" }
+      ]
+    }
+  ],
+  rules: [
+    { field: "output_format", value: "typescript", source: "software_default" },
+    { field: "style", value: "technical", source: "software_default" }
+  ]
+};
+var CONTENT_PACK = {
+  id: "pack-content",
+  name: "Content Creation",
+  industry: "content",
+  description: "SEO rules, platform norms, content calendar templates",
+  knowledge: [
+    { summary: "Blog posts between 1500-2500 words rank highest on Google", tags: ["seo", "blog", "word_count"], partition: "global" },
+    { summary: "Use H2/H3 headers every 300 words for readability", tags: ["seo", "structure", "readability"], partition: "global" },
+    { summary: "Meta descriptions should be 150-160 characters", tags: ["seo", "meta", "description"], partition: "global" },
+    { summary: "Include at least one internal and one external link per 500 words", tags: ["seo", "links"], partition: "global" },
+    { summary: "Twitter/X posts perform best at 71-100 characters", tags: ["social_media", "twitter", "length"], partition: "global" }
+  ],
+  templates: [
+    {
+      id: "tmpl-seo-content",
+      name: "SEO Content Evaluation",
+      taskTypes: ["blog_post", "article", "landing_page"],
+      dimensions: [
+        { name: "word_count", weight: 0.15, evaluator: "auto", autoCheck: checkWordCount(1e3, 3e3) },
+        { name: "heading_structure", weight: 0.15, evaluator: "auto", autoCheck: (output) => {
+          const h = output.match(/^#{2,3}\s/gm);
+          return h ? Math.min(h.length / 5, 1) : 0;
+        } },
+        { name: "keyword_density", weight: 0.2, evaluator: "auto", autoCheck: checkFormatCompliance("markdown") },
+        { name: "readability", weight: 0.25, evaluator: "agent_review", description: "Easy to read for target audience?" },
+        { name: "seo_optimization", weight: 0.25, evaluator: "human", description: "Properly optimized for search?" }
+      ]
+    }
+  ],
+  rules: [
+    { field: "output_format", value: "markdown", source: "content_default" },
+    { field: "style", value: "engaging", source: "content_default" }
+  ]
+};
+var ALL_PACKS = {
+  marketing: MARKETING_PACK,
+  software: SOFTWARE_DEV_PACK,
+  content: CONTENT_PACK
+};
+function getPackKnowledge(packId) {
+  const pack = Object.values(ALL_PACKS).find((p) => p.id === packId);
+  return pack?.knowledge ?? [];
+}
+function getPackTemplates(packId) {
+  const pack = Object.values(ALL_PACKS).find((p) => p.id === packId);
+  return pack?.templates ?? [];
+}
+function getPackRules(packId) {
+  const pack = Object.values(ALL_PACKS).find((p) => p.id === packId);
+  return pack?.rules ?? [];
+}
+function listPacks() {
+  return Object.values(ALL_PACKS).map((p) => ({
+    id: p.id,
+    name: p.name,
+    industry: p.industry,
+    description: p.description
+  }));
+}
+
+// ecosystem/dashboard.ts
+function computeOverview(experiences) {
+  const active = experiences.filter((e) => e.status === "active");
+  const hypos = experiences.filter((e) => e.status === "hypothesis");
+  const rolled = experiences.filter((e) => e.status === "rolled_back");
+  const abstracts = experiences.filter((e) => e.is_abstract);
+  const avgConf = experiences.length > 0 ? experiences.reduce((s, e) => s + e.confidence, 0) / experiences.length : 0;
+  return {
+    totalTasks: 0,
+    // Filled externally
+    totalExperiences: experiences.length,
+    activeExperiences: active.length,
+    hypotheses: hypos.length,
+    rolledBack: rolled.length,
+    abstractMethods: abstracts.length,
+    avgConfidence: Number(avgConf.toFixed(3))
+  };
+}
+function computeRetrievalStats(traces) {
+  if (traces.length === 0) {
+    return { totalQueries: 0, avgHitsPerQuery: 0, avgInjectedPerQuery: 0, topPartitions: [], topTags: [] };
+  }
+  const partitionCounts = /* @__PURE__ */ new Map();
+  const tagCounts = /* @__PURE__ */ new Map();
+  let totalHits = 0;
+  let totalInjected = 0;
+  for (const trace of traces) {
+    totalHits += trace.hits.length;
+    totalInjected += trace.injected.length;
+    for (const p of trace.partitions_searched) {
+      partitionCounts.set(p, (partitionCounts.get(p) ?? 0) + 1);
+    }
+    for (const t of trace.query_tags) {
+      tagCounts.set(t, (tagCounts.get(t) ?? 0) + 1);
+    }
+  }
+  const topPartitions = [...partitionCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([partition, count]) => ({ partition, count }));
+  const topTags = [...tagCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([tag, count]) => ({ tag, count }));
+  return {
+    totalQueries: traces.length,
+    avgHitsPerQuery: Number((totalHits / traces.length).toFixed(2)),
+    avgInjectedPerQuery: Number((totalInjected / traces.length).toFixed(2)),
+    topPartitions,
+    topTags
+  };
+}
+function computeAttributionBreakdown(attributions) {
+  const byTarget = {};
+  let actionableCount = 0;
+  for (const attr of attributions) {
+    byTarget[attr.primaryCause] = (byTarget[attr.primaryCause] ?? 0) + 1;
+    if (attr.actionable) actionableCount++;
+  }
+  const topIssues = Object.entries(byTarget).sort((a, b) => b[1] - a[1]).map(([target, count]) => ({ target, count }));
+  return {
+    total: attributions.length,
+    byTarget,
+    actionableRate: attributions.length > 0 ? Number((actionableCount / attributions.length).toFixed(3)) : 0,
+    topIssues
+  };
+}
+function computeDeviationTrends(analyses) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const a of analyses) {
+    for (const d of a.deviations) {
+      const key = `${a.taskType}::${d.dimension}`;
+      const group = groups.get(key) ?? [];
+      group.push(a);
+      groups.set(key, group);
+    }
+  }
+  const trends = [];
+  for (const [key, group] of groups) {
+    const [taskType, dimension] = key.split("::");
+    const deviations = group.flatMap((a) => a.deviations.filter((d) => d.dimension === dimension));
+    const avgRatio = deviations.reduce((s, d) => s + d.ratio, 0) / deviations.length;
+    const dist = { normal: 0, mild: 0, significant: 0, reverse: 0 };
+    for (const d of deviations) dist[d.level]++;
+    trends.push({ taskType, dimension, avgRatio: Number(avgRatio.toFixed(3)), levelDistribution: dist });
+  }
+  return trends;
+}
+function computePropagationFlow(experiences) {
+  const published = experiences.filter((e) => e.partition === "global" && e.status === "active");
+  const verified = experiences.filter((e) => e.verified_count > 0);
+  const avgVC = experiences.length > 0 ? experiences.reduce((s, e) => s + e.verified_count, 0) / experiences.length : 0;
+  return {
+    totalPublished: published.length,
+    totalVerified: verified.length,
+    totalChallenged: experiences.filter((e) => e.status === "hypothesis").length,
+    avgVerifiedCount: Number(avgVC.toFixed(2))
+  };
+}
+
+// utils/fallback.ts
+async function safeguard(fn, fallbackValue, options) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (options?.logError !== false) {
+      console.error("[AgentEvolve] Fallback:", error);
+    }
+    return fallbackValue;
+  }
+}
+export {
+  ALL_PACKS,
+  CONTENT_PACK,
+  Codec,
+  DEFAULT_ATTENTION_BUDGET,
+  DEFAULT_ROUGH_INTENT,
+  DEFAULT_THRESHOLD,
+  DeviationAccumulator,
+  EXTRACTION_PROMPT,
+  FEEDBACK_TEMPLATES,
+  IndexTable,
+  MARKETING_PACK,
+  SOFTWARE_DEV_PACK,
+  TEMPLATES,
+  TemplateMarket,
+  abstractify,
+  analyzeAttribution,
+  analyzePrediction,
+  assembleContext,
+  attributeIntentError,
+  attributeOutputError,
+  attributeRetrievalError,
+  autoIngest,
+  buildPerformanceWindow,
+  buildQuestions,
+  buildSourceTrace,
+  buildTrace,
+  calcConfidence,
+  challengeExperience,
+  checkFormatCompliance,
+  checkKeywordCoverage,
+  checkPerformanceDegradation,
+  checkWordCount,
+  computeAttributionBreakdown,
+  computeDeviationTrends,
+  computeOverview,
+  computePropagationFlow,
+  computeRetrievalStats,
+  confirmIfNeeded,
+  conflictDetect,
+  contextFill,
+  contextFillRefine,
+  createExperienceEntry,
+  decideRollback,
+  dedup,
+  distillGroup,
+  evaluate,
+  executeRollback,
+  extractConstraints,
+  extractKeywords,
+  extractTags,
+  filterPropagatable,
+  findDistillationCandidates,
+  getPackKnowledge,
+  getPackRules,
+  getPackTemplates,
+  groupByField,
+  intentPipeline,
+  isConflicting,
+  listPacks,
+  normalizeFeedback,
+  parseIntentBlock,
+  publishToGlobal,
+  rankByReliability,
+  resolvePartition,
+  resolveSource,
+  routeExperience,
+  runDistillation,
+  runVerification,
+  safeguard,
+  selectAttentionSlots,
+  selectTemplate,
+  stripIntentBlock,
+  structure,
+  summarizeFeedback,
+  updateIntent,
+  verifyExperience,
+  verifyFieldPresence,
+  verifyJsonSchema,
+  verifyRegex
+};