@herjarsa/omo-meta-governor 0.1.0

package/dist/index.js

@@ -0,0 +1,1049 @@
+// @bun
+// src/memory-aggregator.ts
+var DEFAULTS = {
+  limits: { maxLessons: 10, maxSlots: 20, maxTasks: 10 },
+  timeouts: { agentmemoryMs: 2000, magicContextMs: 1000, boulderStateMs: 1000 }
+};
+async function aggregateRead(input, backends) {
+  const start = performance.now();
+  const limits = { ...DEFAULTS.limits, ...input.limits };
+  const timeouts = { ...DEFAULTS.timeouts, ...input.timeouts };
+  const [agentResult, magicResult, boulderResult] = await Promise.allSettled([
+    readAgentmemory(input, backends.agentmemory, limits, timeouts.agentmemoryMs),
+    readMagicContext(input, backends.magicContext, limits, timeouts.magicContextMs),
+    readBoulderState(input, backends.boulderState, limits, timeouts.boulderStateMs)
+  ]);
+  const degradedSources = [];
+  const errorMessages = {};
+  const agentmemory = agentResult.status === "fulfilled" ? agentResult.value : (pushDegraded(degradedSources, errorMessages, "agentmemory", errorMessage(agentResult.reason)), DEGRADED.agentmemory);
+  const magicContext = magicResult.status === "fulfilled" ? magicResult.value : (pushDegraded(degradedSources, errorMessages, "magicContext", errorMessage(magicResult.reason)), DEGRADED.magicContext);
+  const boulderState = boulderResult.status === "fulfilled" ? boulderResult.value : (pushDegraded(degradedSources, errorMessages, "boulderState", errorMessage(boulderResult.reason)), DEGRADED.boulderState);
+  return {
+    query: input.query,
+    timestampISO: new Date().toISOString(),
+    agentmemory,
+    magicContext,
+    boulderState,
+    degradedSources,
+    durationMs: performance.now() - start,
+    errorMessages
+  };
+}
+async function readAgentmemory(input, backend, limits, timeoutMs) {
+  const search = await withTimeout(backend.smartSearch({ query: input.query, limit: limits.maxLessons }), timeoutMs, "agentmemory");
+  const lessons = sortByConfidence(search.lessons).slice(0, limits.maxLessons).map((l) => ({
+    id: l.id,
+    title: l.title,
+    advice: "info",
+    confidence: l.confidence,
+    concepts: l.concepts
+  }));
+  return {
+    available: true,
+    lessons
+  };
+}
+async function readMagicContext(input, backend, limits, timeoutMs) {
+  const slots = await withTimeout(backend.slotList({ directory: input.directory }), timeoutMs, "magicContext");
+  return {
+    available: true,
+    slots: slots.filter((s) => s.label.startsWith("meta_governor:") || isRelevant(s, input.query)).sort((a, b) => a.label.localeCompare(b.label)).slice(0, limits.maxSlots).map((s) => ({ label: s.label, content: s.content }))
+  };
+}
+async function readBoulderState(input, backend, limits, timeoutMs) {
+  const tasks = await withTimeout(backend.boulderRead({ directory: input.directory, sessionID: input.sessionID, query: input.query }), timeoutMs, "boulderState");
+  const sorted = tasks.sort((a, b) => a.priority - b.priority || b.updatedAtMs - a.updatedAtMs).slice(0, limits.maxTasks);
+  return {
+    available: true,
+    tasks: sorted.map((t) => ({ id: t.id, status: t.status, title: t.title })),
+    planProgress: computePlanProgress(tasks)
+  };
+}
+function sortByConfidence(lessons) {
+  return [...lessons].sort((a, b) => b.confidence - a.confidence);
+}
+function isRelevant(slot, query) {
+  const q = query.toLowerCase();
+  return slot.label.toLowerCase().includes(q) || slot.content.toLowerCase().includes(q);
+}
+function computePlanProgress(tasks) {
+  if (tasks.length === 0)
+    return 0;
+  const done = tasks.filter((t) => t.status === "done").length;
+  return done / tasks.length;
+}
+function errorMessage(err) {
+  if (err instanceof Error)
+    return err.message;
+  if (typeof err === "string")
+    return err;
+  return "unknown error";
+}
+function pushDegraded(list, errorMessages, source, reason) {
+  list.push(source);
+  errorMessages[source] = reason;
+}
+var DEGRADED = {
+  agentmemory: { available: false, lessons: [] },
+  magicContext: { available: false, slots: [] },
+  boulderState: { available: false, tasks: [], planProgress: 0 }
+};
+async function withTimeout(p, ms, label) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label} timeout after ${ms}ms`)), ms);
+    p.then((v) => {
+      clearTimeout(t);
+      resolve(v);
+    }, (e) => {
+      clearTimeout(t);
+      reject(e);
+    });
+  });
+}
+
+// src/token-predictor.ts
+function defaultTokenPredictorConfig() {
+  return {
+    compactBurnRateThreshold: 500,
+    compactUsageThreshold: 0.85,
+    switchModelUsageThreshold: 0.95,
+    delegateConsecutiveHighBurn: 5,
+    windowSize: 10
+  };
+}
+function calculateBurnRate(recentTurnTokens) {
+  if (recentTurnTokens.length === 0)
+    return 0;
+  const sum = recentTurnTokens.reduce((a, b) => a + b, 0);
+  return sum / recentTurnTokens.length;
+}
+function countConsecutiveHighBurn(recentTurnTokens, threshold) {
+  let count = 0;
+  for (let i = recentTurnTokens.length - 1;i >= 0; i--) {
+    if (recentTurnTokens[i] >= threshold) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+function predictOverflowTime(currentUsage, modelLimit, burnRate, timestampISO) {
+  const budgetLeft = modelLimit - currentUsage;
+  if (budgetLeft <= 0)
+    return timestampISO;
+  if (burnRate <= 0)
+    return null;
+  const turnsLeft = Math.floor(budgetLeft / burnRate);
+  if (turnsLeft <= 0)
+    return timestampISO;
+  const secondsLeft = turnsLeft * 2;
+  const overflowDate = new Date(new Date(timestampISO).getTime() + secondsLeft * 1000);
+  return overflowDate.toISOString();
+}
+function predict(input) {
+  const { currentUsage, modelLimit, recentTurnTokens, timestampISO, config } = input;
+  const windowTokens = recentTurnTokens.slice(-config.windowSize);
+  const burnRate = calculateBurnRate(windowTokens);
+  const budgetLeft = modelLimit - currentUsage;
+  const usageRatio = modelLimit > 0 ? currentUsage / modelLimit : 1;
+  const confidence = Math.min(0.95, 0.3 + windowTokens.length / config.windowSize * 0.65);
+  let recommendation = "no-action";
+  let reason = "within normal parameters";
+  if (usageRatio >= config.switchModelUsageThreshold) {
+    recommendation = "switch-model";
+    reason = `context usage ${(usageRatio * 100).toFixed(1)}% exceeds switch threshold ${(config.switchModelUsageThreshold * 100).toFixed(1)}%`;
+  }
+  if (usageRatio >= config.compactUsageThreshold || burnRate >= config.compactBurnRateThreshold) {
+    if (recommendation === "no-action") {
+      recommendation = "compact-now";
+      reason = usageRatio >= config.compactUsageThreshold ? `context usage ${(usageRatio * 100).toFixed(1)}% exceeds compact threshold ${(config.compactUsageThreshold * 100).toFixed(1)}%` : `burn rate ${burnRate.toFixed(0)} tokens/turn exceeds threshold ${config.compactBurnRateThreshold}`;
+    }
+  }
+  const consecutiveHighBurn = countConsecutiveHighBurn(windowTokens, config.compactBurnRateThreshold);
+  if (consecutiveHighBurn >= config.delegateConsecutiveHighBurn && recommendation === "no-action") {
+    recommendation = "delegate-to-subagent";
+    reason = `${consecutiveHighBurn} consecutive high-burn turns (threshold: ${config.delegateConsecutiveHighBurn})`;
+  }
+  const willOverflowAt = predictOverflowTime(currentUsage, modelLimit, burnRate, timestampISO);
+  return {
+    currentUsage,
+    burnRate,
+    budgetLeft,
+    willOverflowAt,
+    recommendation,
+    confidence,
+    modelLimit,
+    windowRemaining: Math.max(0, Math.floor(budgetLeft / Math.max(burnRate, 1))),
+    input: { ...input },
+    computedAtISO: timestampISO,
+    turnsAnalyzed: windowTokens.length
+  };
+}
+
+// src/scoring-engine.ts
+var DEFAULT_WEIGHTS = {
+  "oracle-verified": 0.25,
+  "no-progress-detector": 0.2,
+  "deviation-detector": 0.2,
+  "iteration-budget": 0.15,
+  "lesson-recall": 0.1,
+  "token-predictor": 0.1
+};
+var defaultScoringConfig = () => ({
+  continueThreshold: 0.3,
+  warnThreshold: 0.3,
+  escalateThreshold: 0.6,
+  stopThreshold: 0.8,
+  paralysisThreshold: 3,
+  defaultEscalationTarget: "oracle"
+});
+function scoreSignals(ctx) {
+  const contributions = [];
+  contributions.push({
+    source: "oracle-verified",
+    rawScore: ctx.oracleVerified ? 0.6 : 0,
+    weight: DEFAULT_WEIGHTS["oracle-verified"],
+    weightedScore: ctx.oracleVerified ? 0.6 * DEFAULT_WEIGHTS["oracle-verified"] : 0,
+    description: ctx.oracleVerified ? "Oracle verification passed" : "No Oracle verification"
+  });
+  contributions.push({
+    source: "no-progress-detector",
+    rawScore: ctx.noProgress ? -0.8 : 0,
+    weight: DEFAULT_WEIGHTS["no-progress-detector"],
+    weightedScore: ctx.noProgress ? -0.8 * DEFAULT_WEIGHTS["no-progress-detector"] : 0,
+    description: ctx.noProgress ? "No progress detected in last turn" : "Progress detected"
+  });
+  const deviationScore = scoreDeviations(ctx.deviations);
+  contributions.push({
+    source: "deviation-detector",
+    rawScore: deviationScore,
+    weight: DEFAULT_WEIGHTS["deviation-detector"],
+    weightedScore: deviationScore * DEFAULT_WEIGHTS["deviation-detector"],
+    description: ctx.deviations.length > 0 ? `${ctx.deviations.length} deviation(s) detected (worst: ${ctx.deviations[0].severity})` : "No deviations detected"
+  });
+  const iterationScore = scoreIterationBudget(ctx.iterationRatio);
+  contributions.push({
+    source: "iteration-budget",
+    rawScore: iterationScore,
+    weight: DEFAULT_WEIGHTS["iteration-budget"],
+    weightedScore: iterationScore * DEFAULT_WEIGHTS["iteration-budget"],
+    description: `Iteration ratio: ${ctx.iterationRatio.toFixed(2)} (${ctx.ambient.iteration}/${ctx.ambient.maxIterations})`
+  });
+  const lessonScore = scoreLessons(ctx.lessonsRelevant);
+  contributions.push({
+    source: "lesson-recall",
+    rawScore: lessonScore,
+    weight: DEFAULT_WEIGHTS["lesson-recall"],
+    weightedScore: lessonScore * DEFAULT_WEIGHTS["lesson-recall"],
+    description: ctx.lessonsRelevant.length > 0 ? `${ctx.lessonsRelevant.length} relevant lesson(s) (avg confidence: ${avgConfidence(ctx.lessonsRelevant).toFixed(2)})` : "No relevant lessons"
+  });
+  return contributions;
+}
+function scoreDeviations(deviations) {
+  if (deviations.length === 0)
+    return 0;
+  const severityMap = {
+    grave: -0.9,
+    media: -0.5,
+    leve: -0.2
+  };
+  let worst = 0;
+  for (const d of deviations) {
+    const s = severityMap[d.severity] ?? -0.3;
+    if (s < worst)
+      worst = s;
+  }
+  const amplification = Math.min(deviations.length * 0.05, 0.2);
+  return Math.max(worst - amplification, -1);
+}
+function scoreIterationBudget(ratio) {
+  if (ratio <= 0.5)
+    return -ratio * 0.6;
+  return -0.3 - (ratio - 0.5) * 1;
+}
+function scoreLessons(lessons) {
+  if (lessons.length === 0)
+    return 0;
+  let totalScore = 0;
+  for (const lesson of lessons) {
+    const adviceScore = {
+      continue: 0.3,
+      info: 0,
+      warn: -0.3,
+      stop: -0.7
+    };
+    totalScore += (adviceScore[lesson.advice] ?? 0) * lesson.confidence;
+  }
+  return Math.max(Math.min(totalScore / lessons.length, 1), -1);
+}
+function avgConfidence(lessons) {
+  if (lessons.length === 0)
+    return 0;
+  return lessons.reduce((sum, l) => sum + l.confidence, 0) / lessons.length;
+}
+function mapScoreToAction(score, config) {
+  if (score >= config.continueThreshold)
+    return "continue";
+  if (score <= -config.stopThreshold)
+    return "stop";
+  if (score <= -config.escalateThreshold)
+    return "escalate";
+  if (score <= -config.warnThreshold)
+    return "warn";
+  return "continue";
+}
+function selectEscalationTarget(ctx, config) {
+  if (!ctx.oracleVerified)
+    return "oracle";
+  if (ctx.deviations.some((d) => d.severity === "grave"))
+    return "user";
+  return config.defaultEscalationTarget;
+}
+function buildReasoning(score, action, contributions, paralysisOverride) {
+  if (paralysisOverride) {
+    return `Paralysis detected: forced continue despite score ${score.toFixed(3)} (too many consecutive stops)`;
+  }
+  const sorted = [...contributions].sort((a, b) => a.weightedScore - b.weightedScore);
+  const worst = sorted[0];
+  const best = sorted[sorted.length - 1];
+  const parts = [];
+  if (worst.weightedScore < 0) {
+    parts.push(`primary concern: ${worst.description}`);
+  }
+  if (best.weightedScore > 0) {
+    parts.push(`positive signal: ${best.description}`);
+  }
+  const actionLabel = {
+    continue: "Continue",
+    warn: "Warn",
+    escalate: "Escalate",
+    stop: "Stop"
+  };
+  return `${actionLabel[action]} (score: ${score.toFixed(3)}): ${parts.join("; ") || "balanced signals"}`;
+}
+function score(ctx, config) {
+  const resolvedConfig = { ...defaultScoringConfig(), ...config };
+  const contributions = scoreSignals(ctx);
+  const rawScore = contributions.reduce((sum, c) => sum + c.weightedScore, 0);
+  const clampedScore = Math.max(Math.min(rawScore, 1), -1);
+  const paralysisOverride = ctx.slotMemory.consecutiveStops >= resolvedConfig.paralysisThreshold && clampedScore <= -resolvedConfig.warnThreshold;
+  const action = paralysisOverride ? "continue" : mapScoreToAction(clampedScore, resolvedConfig);
+  const evidence = [];
+  if (action !== "continue" || Math.abs(clampedScore) < resolvedConfig.continueThreshold) {
+    for (const c of contributions) {
+      if (Math.abs(c.weightedScore) > 0.01) {
+        evidence.push({
+          source: c.source,
+          value: c.description,
+          confidence: Math.abs(c.rawScore),
+          weight: c.weight
+        });
+      }
+    }
+    if (evidence.length === 0 && action !== "continue") {
+      evidence.push({
+        source: "ambient",
+        value: buildReasoning(clampedScore, action, contributions, paralysisOverride),
+        confidence: 0.5,
+        weight: 0.1
+      });
+    }
+  }
+  const shouldEscalateTo = action === "escalate" ? selectEscalationTarget(ctx, resolvedConfig) : null;
+  const decision = {
+    action,
+    score: clampedScore,
+    reasoning: buildReasoning(clampedScore, action, contributions, paralysisOverride),
+    evidence,
+    shouldEscalateTo
+  };
+  return {
+    decision,
+    contributions,
+    rawScore: clampedScore,
+    paralysisOverride,
+    computedAtISO: new Date().toISOString()
+  };
+}
+
+// src/decision-handler.ts
+var defaultDecisionHandlerConfig = () => ({
+  enabled: true,
+  maxHistoryPerSession: 50,
+  forceContinueAfterStops: 3,
+  warnMessageTemplate: "[MetaGovernor] Score {score}: {reasoning}. Evidence: {evidenceCount} signal(s).",
+  escalateMessageTemplate: "[MetaGovernor] Escalating to {target}: {reasoning}",
+  stopMessageTemplate: "[MetaGovernor] STOP \u2014 {reasoning}. Evidence: {evidenceCount} signal(s)."
+});
+function formatMessage(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{${key}}`, value);
+  }
+  return result;
+}
+function evidenceCount(evidence) {
+  return evidence.length;
+}
+function handleDecision(input, config) {
+  const resolvedConfig = { ...defaultDecisionHandlerConfig(), ...config };
+  if (!resolvedConfig.enabled) {
+    return {
+      action: "continue",
+      message: null,
+      historyEntry: {
+        decision: input.scoringResult.decision,
+        action: "continue",
+        timestampISO: new Date().toISOString(),
+        sessionID: input.sessionID,
+        reasoning: "Decision handler disabled \u2014 pass-through continue"
+      }
+    };
+  }
+  const decision = input.scoringResult.decision;
+  const score2 = decision.score;
+  const reasoning = decision.reasoning;
+  const evCount = evidenceCount(decision.evidence);
+  const target = decision.shouldEscalateTo ?? resolvedConfig.defaultEscalationTarget ?? "oracle";
+  if (input.scoringResult.paralysisOverride) {
+    const message = formatMessage(resolvedConfig.warnMessageTemplate, {
+      score: score2.toFixed(3),
+      reasoning: `Paralysis detected \u2014 forced continue. ${reasoning}`,
+      evidenceCount: String(evCount)
+    });
+    return {
+      action: "continue",
+      message,
+      historyEntry: {
+        decision,
+        action: "continue",
+        timestampISO: new Date().toISOString(),
+        sessionID: input.sessionID,
+        reasoning: `Paralysis override: ${reasoning}`
+      }
+    };
+  }
+  switch (decision.action) {
+    case "continue": {
+      return {
+        action: "continue",
+        message: null,
+        historyEntry: {
+          decision,
+          action: "continue",
+          timestampISO: new Date().toISOString(),
+          sessionID: input.sessionID,
+          reasoning
+        }
+      };
+    }
+    case "warn": {
+      const message = formatMessage(resolvedConfig.warnMessageTemplate, {
+        score: score2.toFixed(3),
+        reasoning,
+        evidenceCount: String(evCount)
+      });
+      return {
+        action: "warn",
+        message,
+        historyEntry: {
+          decision,
+          action: "warn",
+          timestampISO: new Date().toISOString(),
+          sessionID: input.sessionID,
+          reasoning
+        }
+      };
+    }
+    case "escalate": {
+      const message = formatMessage(resolvedConfig.escalateMessageTemplate, {
+        target,
+        reasoning
+      });
+      return {
+        action: "escalate",
+        message,
+        historyEntry: {
+          decision,
+          action: "escalate",
+          timestampISO: new Date().toISOString(),
+          sessionID: input.sessionID,
+          reasoning: `Escalate to ${target}: ${reasoning}`
+        }
+      };
+    }
+    case "stop": {
+      const message = formatMessage(resolvedConfig.stopMessageTemplate, {
+        reasoning,
+        evidenceCount: String(evCount)
+      });
+      return {
+        action: "stop",
+        message,
+        historyEntry: {
+          decision,
+          action: "stop",
+          timestampISO: new Date().toISOString(),
+          sessionID: input.sessionID,
+          reasoning
+        }
+      };
+    }
+  }
+}
+function trimHistory(history, maxSize) {
+  if (history.length <= maxSize) {
+    return { trimmed: [...history], dropped: 0 };
+  }
+  const dropped = history.length - maxSize;
+  return { trimmed: history.slice(-maxSize), dropped };
+}
+function countConsecutiveStops(history) {
+  let count = 0;
+  for (let i = history.length - 1;i >= 0; i--) {
+    if (history[i].action === "stop") {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
+// src/closed-loop-learning.ts
+var SEVERITY_ORDER = {
+  leve: 0,
+  media: 1,
+  grave: 2
+};
+function generateDecisionId(sessionID, action, timestamp) {
+  const hash = `${sessionID}-${action}-${timestamp}`.split("").reduce((a, c) => (a << 5) - a + c.charCodeAt(0) | 0, 0);
+  return `D-${Math.abs(hash).toString(36)}`;
+}
+function severityMeetsThreshold(deviations, threshold) {
+  const minOrder = SEVERITY_ORDER[threshold] ?? 0;
+  return deviations.some((d) => (SEVERITY_ORDER[d.severity] ?? 0) >= minOrder);
+}
+function extractConcepts(deviations) {
+  const concepts = new Set;
+  for (const d of deviations) {
+    concepts.add(d.category);
+    concepts.add(d.severity);
+  }
+  return [...concepts];
+}
+function buildLessonContent(decision, deviations) {
+  const deviationSummary = deviations.map((d) => `[${d.severity}] ${d.category}: ${d.detail}`).join("; ");
+  return `Action "${decision.action}" (score ${decision.score.toFixed(2)}) after deviations: ${deviationSummary}. Reasoning: ${decision.reasoning}`;
+}
+async function observeAndLearn(input, backend) {
+  const { decision, config, sessionID, directory, filesChanged } = input;
+  const now = new Date().toISOString();
+  if (!config.enabled) {
+    return { lessonSaved: null, decisionSaved: null, reason: "closed-loop learning disabled" };
+  }
+  if (decision.evidence.length === 0 && decision.action === "continue") {
+    return { lessonSaved: null, decisionSaved: null, reason: "no deviations to learn from" };
+  }
+  let lessonSaved = null;
+  let decisionSaved = null;
+  if (config.saveDecisions) {
+    const decisionRecord = {
+      id: generateDecisionId(sessionID, decision.action, now),
+      timestampISO: now,
+      action: decision.action,
+      score: decision.score,
+      reasoning: decision.reasoning,
+      sessionID,
+      directory,
+      deviations: decision.evidence.filter((e) => e.source === "deviation-detector").map((e) => ({
+        severity: "media",
+        category: e.source,
+        detail: e.value
+      }))
+    };
+    try {
+      await backend.saveMemory({
+        content: `Decision: ${decision.action} (score ${decision.score.toFixed(2)}). ${decision.reasoning}`,
+        concepts: ["meta-governor", "decision", decision.action],
+        type: "fact",
+        files: [...filesChanged]
+      });
+      decisionSaved = decisionRecord;
+    } catch {}
+  }
+  const deviationsFromEvidence = decision.evidence.filter((e) => e.source === "deviation-detector").map((e) => ({
+    severity: "media",
+    category: e.source,
+    detail: e.value
+  }));
+  if (severityMeetsThreshold(deviationsFromEvidence, config.minSeverityToLearn)) {
+    const concepts = extractConcepts(deviationsFromEvidence);
+    const content = buildLessonContent(decision, deviationsFromEvidence);
+    try {
+      const result = await backend.saveLesson({
+        content,
+        context: `session:${sessionID} dir:${directory}`,
+        confidence: Math.max(0.3, Math.min(0.8, Math.abs(decision.score))),
+        tags: concepts
+      });
+      lessonSaved = {
+        id: result.id,
+        title: `${decision.action} after ${deviationsFromEvidence[0]?.category ?? "deviation"}`,
+        content,
+        type: "pattern",
+        concepts,
+        confidence: Math.max(0.3, Math.min(0.8, Math.abs(decision.score))),
+        files: [...filesChanged],
+        sessionID
+      };
+    } catch {}
+  }
+  const reasons = [];
+  if (decisionSaved)
+    reasons.push("decision saved");
+  if (lessonSaved)
+    reasons.push("lesson saved");
+  if (!decisionSaved && !lessonSaved) {
+    if (!severityMeetsThreshold(deviationsFromEvidence, config.minSeverityToLearn)) {
+      reasons.push("severity below threshold");
+    } else {
+      reasons.push("no saveable content");
+    }
+  }
+  return {
+    lessonSaved,
+    decisionSaved,
+    reason: reasons.join("; ") || "no action taken"
+  };
+}
+function defaultClosedLoopConfig() {
+  return {
+    enabled: true,
+    minSeverityToLearn: "media",
+    maxLessonsPerSession: 20,
+    saveDecisions: true
+  };
+}
+
+// src/orchestrator.ts
+var defaultOrchestratorConfig = () => ({
+  enabled: true,
+  memory: { enabled: true, query: "", timeoutMs: 3000 },
+  tokenPredictor: {},
+  scoring: {},
+  decision: {},
+  closedLoop: {}
+});
+var EMPTY_MEMORY_READ = {
+  query: "",
+  timestampISO: new Date().toISOString(),
+  agentmemory: { available: false, lessons: [] },
+  magicContext: { available: false, slots: [] },
+  boulderState: { available: false, tasks: [], planProgress: 0 },
+  degradedSources: ["agentmemory", "magicContext", "boulderState"]
+};
+var EMPTY_SLOT_MEMORY = {
+  consecutiveStops: 0,
+  consecutiveContinues: 0,
+  lastUpdatedISO: new Date().toISOString()
+};
+var NO_OP_DECISION = {
+  action: "continue",
+  message: null,
+  historyEntry: {
+    decision: {
+      action: "continue",
+      score: 0,
+      reasoning: "no decision made",
+      evidence: [],
+      shouldEscalateTo: null
+    },
+    action: "continue",
+    timestampISO: new Date().toISOString(),
+    sessionID: "",
+    reasoning: "no decision made"
+  }
+};
+function buildDecisionContext(input, memoryRead = EMPTY_MEMORY_READ) {
+  const iterationRatio = input.maxIterations > 0 ? input.iteration / input.maxIterations : 0;
+  const slotMemory = {
+    ...EMPTY_SLOT_MEMORY,
+    consecutiveStops: input.consecutiveStops ?? 0
+  };
+  return {
+    oracleVerified: input.oracleVerified,
+    noProgress: input.noProgress,
+    deviations: input.deviations,
+    iterationRatio,
+    lessonsRelevant: memoryRead.agentmemory.lessons,
+    slotMemory,
+    ambient: {
+      sessionID: input.sessionID,
+      directory: ".",
+      mode: "simple",
+      agentName: input.agentName ?? "unknown",
+      iteration: input.iteration,
+      maxIterations: input.maxIterations
+    }
+  };
+}
+async function runMetaGovernor(input, config = {}) {
+  const mergedConfig = {
+    ...defaultOrchestratorConfig(),
+    ...config
+  };
+  if (!mergedConfig.enabled) {
+    return {
+      memoryRead: EMPTY_MEMORY_READ,
+      tokenPrediction: createNoopPrediction(input),
+      scoringResult: {
+        decision: {
+          action: "continue",
+          score: 0,
+          reasoning: "MetaGovernor disabled",
+          evidence: [],
+          shouldEscalateTo: null
+        },
+        contributions: [],
+        rawScore: 0,
+        paralysisOverride: false,
+        computedAtISO: new Date().toISOString()
+      },
+      decision: NO_OP_DECISION,
+      lessonSaved: null,
+      decisionHistory: [],
+      skipped: true,
+      skipReason: "disabled"
+    };
+  }
+  let memoryRead = EMPTY_MEMORY_READ;
+  if (mergedConfig.memory.enabled) {
+    try {
+      const backends = {
+        agentmemory: input.backends.agentmemory,
+        magicContext: input.backends.magicContext,
+        boulderState: input.backends.boulderState
+      };
+      memoryRead = await aggregateRead({
+        directory: ".",
+        sessionID: input.sessionID,
+        query: mergedConfig.memory.query || input.toolName
+      }, backends);
+    } catch {}
+  }
+  let tokenPrediction;
+  try {
+    tokenPrediction = predict({
+      currentUsage: input.recentTurnTokens.reduce((a, b) => a + b, 0),
+      modelLimit: 200000,
+      recentTurnTokens: input.recentTurnTokens,
+      timestampISO: new Date().toISOString(),
+      providerID: input.providerID ?? "",
+      modelID: input.modelID ?? "",
+      config: mergedConfig.tokenPredictor
+    });
+  } catch {
+    tokenPrediction = createNoopPrediction(input);
+  }
+  const scoringResult = score(buildDecisionContext(input, memoryRead), mergedConfig.scoring);
+  const decisionInput = {
+    sessionID: input.sessionID,
+    scoringResult
+  };
+  const decision = handleDecision(decisionInput, mergedConfig.decision);
+  let lessonSaved = null;
+  try {
+    const learnConfig = mergedConfig.closedLoop;
+    if (learnConfig.enabled !== false) {
+      lessonSaved = await observeAndLearn({
+        decision: decision.historyEntry.decision,
+        memoryRead,
+        config: { ...defaultClosedLoopConfig(), ...mergedConfig.closedLoop },
+        sessionID: input.sessionID,
+        directory: ".",
+        filesChanged: []
+      }, input.writeBackend);
+    }
+  } catch {}
+  return {
+    memoryRead,
+    tokenPrediction,
+    scoringResult,
+    decision,
+    lessonSaved,
+    decisionHistory: [decision.historyEntry],
+    skipped: false
+  };
+}
+function createNoopPrediction(input) {
+  const totalTokens = input.recentTurnTokens.reduce((a, b) => a + b, 0);
+  return {
+    burnRate: 0,
+    budgetLeft: 200000,
+    currentUsage: totalTokens,
+    modelLimit: 200000,
+    willOverflowAt: null,
+    recommendation: "no-action",
+    confidence: 1,
+    windowRemaining: 200000,
+    input: {
+      currentUsage: totalTokens,
+      modelLimit: 200000,
+      recentTurnTokens: input.recentTurnTokens,
+      timestampISO: new Date().toISOString(),
+      providerID: input.providerID ?? "",
+      modelID: input.modelID ?? "",
+      config: {
+        compactBurnRateThreshold: 500,
+        compactUsageThreshold: 0.85,
+        switchModelUsageThreshold: 0.95,
+        delegateConsecutiveHighBurn: 5,
+        windowSize: 10
+      }
+    },
+    computedAtISO: new Date().toISOString(),
+    turnsAnalyzed: input.recentTurnTokens.length
+  };
+}
+
+// src/config.ts
+function loadOrchestratorConfig(pluginConfig) {
+  const full = {
+    enabled: false,
+    ...pluginConfig
+  };
+  const baseScoring = defaultScoringConfig();
+  const baseDecision = defaultDecisionHandlerConfig();
+  const baseClosedLoop = defaultClosedLoopConfig();
+  return {
+    enabled: full.enabled === true,
+    memory: {
+      enabled: true,
+      query: full.memory?.query ?? "meta_governor_context",
+      timeoutMs: full.memory?.agentmemoryTimeoutMs ?? 2000
+    },
+    tokenPredictor: {
+      compactBurnRateThreshold: full.tokenPredictor?.compactBurnRateThreshold ?? 500,
+      compactUsageThreshold: full.tokenPredictor?.compactUsageThreshold ?? 0.85,
+      switchModelUsageThreshold: full.tokenPredictor?.switchModelUsageThreshold ?? 0.95,
+      delegateConsecutiveHighBurn: full.tokenPredictor?.delegateConsecutiveHighBurn ?? 5
+    },
+    scoring: {
+      ...baseScoring,
+      ...full.scoring?.continueThreshold !== undefined ? { continueThreshold: full.scoring.continueThreshold } : {},
+      ...full.scoring?.warnThreshold !== undefined ? { warnThreshold: full.scoring.warnThreshold } : {},
+      ...full.scoring?.escalateThreshold !== undefined ? { escalateThreshold: full.scoring.escalateThreshold } : {},
+      ...full.scoring?.stopThreshold !== undefined ? { stopThreshold: full.scoring.stopThreshold } : {}
+    },
+    closedLoop: {
+      ...baseClosedLoop,
+      ...full.closedLoop?.saveDecisions !== undefined ? { saveDecisions: full.closedLoop.saveDecisions } : {}
+    },
+    decision: {
+      ...baseDecision,
+      ...full.decision?.maxHistoryPerSession !== undefined ? { maxHistoryPerSession: full.decision.maxHistoryPerSession } : {},
+      ...full.decision?.forceContinueAfterStops !== undefined ? { forceContinueAfterStops: full.decision.forceContinueAfterStops } : {}
+    }
+  };
+}
+function isMetaGovernorEnabled(config) {
+  return config?.enabled === true;
+}
+
+// src/plugin.ts
+function createMetaGovernorPlugin(deps = {}) {
+  const plugin = async (input, options) => {
+    const rawConfig = options?.meta_governor ?? {};
+    const config = loadOrchestratorConfig(rawConfig);
+    if (!config.enabled) {
+      return {};
+    }
+    return {
+      "tool.execute.after": async (toolInput, toolOutput) => {
+        if (!config.enabled)
+          return;
+        const orchestratorInput = {
+          sessionID: toolInput.sessionID,
+          toolName: toolInput.tool,
+          toolOutput: toolOutput.output,
+          iteration: 0,
+          maxIterations: 10,
+          oracleVerified: false,
+          noProgress: false,
+          filesChanged: 0,
+          recentTurnTokens: [],
+          deviations: [],
+          backends: deps.backends ?? {
+            agentmemory: {
+              smartSearch: async () => ({ lessons: [], crystals: [] })
+            },
+            magicContext: {
+              slotList: async () => []
+            },
+            boulderState: {
+              boulderRead: async () => []
+            }
+          },
+          writeBackend: deps.writeBackend ?? {
+            saveMemory: async () => ({ id: "" }),
+            saveLesson: async () => ({ id: "" })
+          },
+          config,
+          ...deps.providerID ? { providerID: deps.providerID() } : {},
+          ...deps.modelID ? { modelID: deps.modelID() } : {}
+        };
+        try {
+          await runMetaGovernor(orchestratorInput);
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.error("[meta-governor] orchestrator error:", err);
+          }
+        }
+      }
+    };
+  };
+  return plugin;
+}
+// src/post-repair-recorder.ts
+function buildDecisionFromRecovery(outcome) {
+  const deviation = {
+    severity: outcome.success ? "leve" : "grave",
+    category: `recovery:${outcome.fixStrategy}`,
+    detail: `${outcome.errorCode}: ${outcome.context ?? "no context"}`
+  };
+  return {
+    action: outcome.success ? "continue" : "warn",
+    score: outcome.success ? 0.5 : -0.5,
+    reasoning: `Recovery ${outcome.success ? "succeeded" : "failed"}: ${outcome.fixStrategy} for ${outcome.errorCode}`,
+    evidence: [
+      {
+        source: "deviation-detector",
+        value: deviation.detail,
+        confidence: 1,
+        weight: outcome.success ? 0.3 : 0.8
+      }
+    ],
+    shouldEscalateTo: outcome.success ? null : "oracle"
+  };
+}
+var SEVERITY_ORDER2 = {
+  leve: 0,
+  media: 1,
+  grave: 2
+};
+function severityMeetsThreshold2(deviations, threshold) {
+  const minOrder = SEVERITY_ORDER2[threshold] ?? 0;
+  return deviations.some((d) => (SEVERITY_ORDER2[d.severity] ?? 0) >= minOrder);
+}
+async function recordRecovery(outcome, writeBackend, options) {
+  if (!writeBackend) {
+    return null;
+  }
+  const config = options?.config ?? defaultClosedLoopConfig();
+  const decision = buildDecisionFromRecovery(outcome);
+  if (!config.enabled) {
+    return { lessonSaved: null, decisionSaved: null, reason: "closed-loop learning disabled" };
+  }
+  const deviations = [{
+    severity: outcome.success ? "leve" : "grave",
+    category: `recovery:${outcome.fixStrategy}`,
+    detail: `${outcome.errorCode}: ${outcome.context ?? "no context"}`
+  }];
+  let lessonSaved = null;
+  let decisionSaved = null;
+  if (config.saveDecisions) {
+    const decisionRecord = {
+      id: `D-${Math.abs(`${outcome.sessionID}-${decision.action}-${Date.now()}`.split("").reduce((a, c) => (a << 5) - a + c.charCodeAt(0) | 0, 0)).toString(36)}`,
+      timestampISO: new Date().toISOString(),
+      action: decision.action,
+      score: decision.score,
+      reasoning: decision.reasoning,
+      sessionID: outcome.sessionID,
+      directory: outcome.directory,
+      deviations: deviations.map((d) => ({
+        severity: d.severity,
+        category: d.category,
+        detail: d.detail
+      }))
+    };
+    try {
+      await writeBackend.saveMemory({
+        content: `Decision: ${decision.action} (score ${decision.score.toFixed(2)}). ${decision.reasoning}`,
+        concepts: ["meta-governor", "decision", decision.action, ...deviations.map((d) => d.category)],
+        type: "fact",
+        files: [...outcome.filesChanged ?? []]
+      });
+      decisionSaved = decisionRecord;
+    } catch {}
+  }
+  if (severityMeetsThreshold2(deviations, config.minSeverityToLearn)) {
+    const concepts = [...new Set(deviations.flatMap((d) => [d.category, d.severity]))];
+    const deviationSummary = deviations.map((d) => `[${d.severity}] ${d.category}: ${d.detail}`).join("; ");
+    const content = `Action "${decision.action}" (score ${decision.score.toFixed(2)}) after deviations: ${deviationSummary}. Reasoning: ${decision.reasoning}`;
+    try {
+      const result = await writeBackend.saveLesson({
+        content,
+        context: `session:${outcome.sessionID} dir:${outcome.directory}`,
+        confidence: Math.max(0.3, Math.min(0.8, Math.abs(decision.score))),
+        tags: concepts
+      });
+      lessonSaved = {
+        id: result.id,
+        title: `${decision.action} after ${deviations[0]?.category ?? "recovery"}`,
+        content,
+        type: "pattern",
+        concepts,
+        confidence: Math.max(0.3, Math.min(0.8, Math.abs(decision.score))),
+        files: [...outcome.filesChanged ?? []],
+        sessionID: outcome.sessionID
+      };
+    } catch {}
+  }
+  const reasons = [];
+  if (decisionSaved)
+    reasons.push("decision saved");
+  if (lessonSaved) {
+    reasons.push("lesson saved");
+  } else if (!severityMeetsThreshold2(deviations, config.minSeverityToLearn)) {
+    reasons.push("severity below threshold");
+  }
+  if (!decisionSaved && !lessonSaved && !reasons.length) {
+    reasons.push("no saveable content");
+  }
+  return {
+    lessonSaved,
+    decisionSaved,
+    reason: reasons.join("; ") || "no action taken"
+  };
+}
+
+// src/index.ts
+var pluginModule = {
+  id: "omo-meta-governor",
+  server: createMetaGovernorPlugin()
+};
+var src_default = pluginModule;
+export {
+  trimHistory,
+  score,
+  runMetaGovernor,
+  recordRecovery,
+  predict,
+  observeAndLearn,
+  loadOrchestratorConfig,
+  isMetaGovernorEnabled,
+  handleDecision,
+  defaultTokenPredictorConfig,
+  defaultScoringConfig,
+  defaultOrchestratorConfig,
+  defaultDecisionHandlerConfig,
+  defaultClosedLoopConfig,
+  src_default as default,
+  createMetaGovernorPlugin,
+  countConsecutiveStops,
+  calculateBurnRate,
+  buildDecisionContext,
+  aggregateRead
+};