vibeoscore 1.0.2 → 1.0.9

package/lib/meta-controller.mjs

@@ -1,499 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: 2026 vibeOS <https://github.com/DrunkkToys/vibeOS>
-// Meta-Controller — maps blackbox resolution state to a unified control vector.
-// v2 orchestration: single source of truth for all subsystem directives.
-// v3: OptimizationMode system — 4 session-level profiles + auto mode.
-
-export type OptimizationMode = "balanced" | "budget" | "speed" | "longrun" | "auto"
-
-export type ControlVector = {
-  enforcement_mode: "relaxed" | "normal" | "strict"
-  enforcement_reason: string
-
-  flow_mode: "audit" | "normal" | "strict"
-  flow_focus: string[]
-
-  tdd_mode: "lazy" | "normal" | "strict" | "quality"
-  tdd_focus: string[]
-
-  tier_bias: "cheap" | "auto" | "medium" | "brain"
-
-  thinking_mode: "off" | "brief" | "full" | "auto"
-
-  stress_multiplier: number
-
-  context7_urgency: "optional" | "preferred" | "required"
-
-  wbp_verbosity: "minimal" | "normal" | "detailed"
-
-  optimization_mode: OptimizationMode
-
-  context_packet: ContextPacket
-
-  directives: string[]
-}
-
-export type ContextPacketKind = "budget" | "speed" | "quality" | "forensic" | "research" | "pivot"
-
-export type ContextPacket = {
-  kind: ContextPacketKind
-  budget_kb: "1-3" | "3-10" | "10-20" | "20-100"
-  title: string
-  summary: string
-  signals: string[]
-}
-
-type RegimeControlMap = Record<string, Omit<ControlVector, "context_packet" | "directives" | "enforcement_reason" | "optimization_mode"> & { enforcement_reason: string }>
-
-const REGIME_CONTROL: RegimeControlMap = {
-  INIT: {
-    enforcement_mode: "normal",
-    enforcement_reason: "fresh session — baseline enforcement",
-    flow_mode: "normal",
-    flow_focus: [],
-    tdd_mode: "normal",
-    tdd_focus: [],
-    tier_bias: "auto",
-    thinking_mode: "auto",
-    stress_multiplier: 1.0,
-    context7_urgency: "preferred",
-    wbp_verbosity: "normal",
-  },
-  DIVERGENT: {
-    enforcement_mode: "relaxed",
-    enforcement_reason: "signals scattered — avoid interrupting exploration",
-    flow_mode: "audit",
-    flow_focus: ["no-write-without-clarification"],
-    tdd_mode: "lazy",
-    tdd_focus: [],
-    tier_bias: "medium",
-    thinking_mode: "off",
-    stress_multiplier: 0.5,
-    context7_urgency: "optional",
-    wbp_verbosity: "detailed",
-  },
-  EXPLORING: {
-    enforcement_mode: "relaxed",
-    enforcement_reason: "user researching — minimal enforcement, save brain for real work",
-    flow_mode: "audit",
-    flow_focus: [],
-    tdd_mode: "lazy",
-    tdd_focus: [],
-    tier_bias: "cheap",
-    thinking_mode: "off",
-    stress_multiplier: 0.7,
-    context7_urgency: "optional",
-    wbp_verbosity: "detailed",
-  },
-  REFINING: {
-    enforcement_mode: "normal",
-    enforcement_reason: "user narrowing down — balanced mode",
-    flow_mode: "normal",
-    flow_focus: [],
-    tdd_mode: "normal",
-    tdd_focus: [],
-    tier_bias: "auto",
-    thinking_mode: "auto",
-    stress_multiplier: 1.0,
-    context7_urgency: "preferred",
-    wbp_verbosity: "normal",
-  },
-  CONVERGING: {
-    enforcement_mode: "strict",
-    enforcement_reason: "user about to commit — full enforcement, catch violations",
-    flow_mode: "strict",
-    flow_focus: ["write-edit-check", "no-untouched-files"],
-    tdd_mode: "strict",
-    tdd_focus: ["skeleton-on-write", "assertion-check"],
-    tier_bias: "brain",
-    thinking_mode: "brief",
-    stress_multiplier: 1.5,
-    context7_urgency: "required",
-    wbp_verbosity: "minimal",
-  },
-  LOOPING: {
-    enforcement_mode: "relaxed",
-    enforcement_reason: "user stuck — relax all enforcement, fresh perspective",
-    flow_mode: "audit",
-    flow_focus: ["suggest-alternative"],
-    tdd_mode: "lazy",
-    tdd_focus: [],
-    tier_bias: "medium",
-    thinking_mode: "off",
-    stress_multiplier: 0.3,
-    context7_urgency: "optional",
-    wbp_verbosity: "detailed",
-  },
-  CLOSED: {
-    enforcement_mode: "strict",
-    enforcement_reason: "finalizing — full enforcement, max stress sensitivity",
-    flow_mode: "strict",
-    flow_focus: ["write-edit-check", "no-untouched-files", "no-lgtm"],
-    tdd_mode: "quality",
-    tdd_focus: ["full-coverage", "edge-cases"],
-    tier_bias: "brain",
-    thinking_mode: "brief",
-    stress_multiplier: 2.0,
-    context7_urgency: "required",
-    wbp_verbosity: "minimal",
-  },
-}
-
-const DEFAULT_CONTROL: Omit<ControlVector, "directives" | "enforcement_reason" | "optimization_mode"> & { enforcement_reason: string } = REGIME_CONTROL.EXPLORING
-
-// ── Optimization Mode Delta Tables ─────────────────────────────────────
-// Each mode defines overrides applied after the base per-regime control vector.
-// "balanced" = no overrides (use per-regime defaults as-is).
-
-type ModeDelta = Partial<Omit<ControlVector, "directives" | "enforcement_reason" | "optimization_mode"> & { loop_threshold?: number; api_enrichment?: boolean; outcome_detection?: boolean }>
-type ContextState = {
-  sub_regime?: string
-  is_looping?: boolean
-  loop_intervention_level?: string
-  momentum?: number
-  n_interactions?: number
-  pivot_detected?: boolean
-  pivot_score?: number
-  continuity_state?: string
-  resolution?: string
-  latest_stress_multiplier?: number
-  user_text?: string
-  prompt?: string
-  features?: Record<string, unknown>
-  action?: string
-  outcome?: string
-  signals?: Record<string, number>
-}
-
-const MODE_DELTAS: Record<Exclude<OptimizationMode, "auto">, ModeDelta> = {
-  balanced: {},
-  budget: {
-    agent_mode: "build",
-    tier_bias: "cheap",
-    thinking_mode: "brief",
-    tdd_mode: "normal",
-    tdd_focus: [],
-    flow_mode: "normal",
-    flow_focus: [],
-    enforcement_mode: "normal",
-    wbp_verbosity: "normal",
-    context7_urgency: "preferred",
-    stress_multiplier: 0.5,
-    loop_threshold: 0.7,
-    api_enrichment: false,
-    outcome_detection: true,
-  },
-  quality: {
-    tier_bias: "brain",
-    thinking_mode: "full",
-    tdd_mode: "quality",
-    tdd_focus: ["full-coverage", "edge-cases", "property-based"],
-    flow_mode: "strict",
-    flow_focus: ["write-edit-check", "no-untouched-files", "no-lgtm", "suggest-alternative"],
-    enforcement_mode: "strict",
-    wbp_verbosity: "detailed",
-    context7_urgency: "required",
-    stress_multiplier: 2.0,
-    loop_threshold: 0.4,
-    api_enrichment: true,
-    outcome_detection: true,
-  },
-  speed: {
-    tier_bias: "medium",
-    thinking_mode: "off",
-    tdd_mode: "lazy",
-    tdd_focus: [],
-    flow_mode: "audit",
-    flow_focus: [],
-    enforcement_mode: "relaxed",
-    wbp_verbosity: "minimal",
-    context7_urgency: "optional",
-    stress_multiplier: 0.0,
-    loop_threshold: 0.9,
-    api_enrichment: false,
-    outcome_detection: false,
-  },
-  longrun: {
-    tier_bias: "brain",
-    thinking_mode: "brief",
-    tdd_mode: "quality",
-    tdd_focus: ["full-coverage", "edge-cases", "skeleton-on-write", "assertion-check"],
-    flow_mode: "strict",
-    flow_focus: ["write-edit-check", "no-untouched-files", "no-lgtm", "suggest-alternative"],
-    enforcement_mode: "strict",
-    wbp_verbosity: "detailed",
-    context7_urgency: "required",
-    stress_multiplier: 1.0,
-    loop_threshold: 0.5,
-    api_enrichment: true,
-    outcome_detection: true,
-  },
-}
-
-export function autoSelectMode(subRegime: string, stressMultiplier?: number, context: { state?: ContextState; recentSignals?: { recentStressAvg?: number; recentStressPeak?: number; repeatRatio?: number; anomalyRate?: number; negativeRate?: number } } = {}): OptimizationMode {
-  const text = String(context.state?.user_text || context.state?.prompt || "").trim()
-  const wordCount = text ? text.split(/\s+/).filter(Boolean).length : 0
-  const hasEvidenceSignal = /error|fail|broken|fix|review|compare|deploy|test|debug|refactor|security|memory leak|pipeline|auth|ci|cd|optimi|validate|inspect|audit|research|study|trace/i.test(text)
-  const recent = context.recentSignals || {}
-  const recentStressAvg = Number(recent.recentStressAvg ?? 0)
-  const recentStressPeak = Number(recent.recentStressPeak ?? 0)
-  const recentAnomalyRate = Number(recent.anomalyRate ?? 0)
-  const recentNegativeRate = Number(recent.negativeRate ?? 0)
-  const elevatedRecentLoad = recentStressAvg > 0.35 || recentStressPeak > 0.6 || recentAnomalyRate > 0.35 || recentNegativeRate > 0.15
-  if (subRegime === "LOOPING") return "speed"
-  if (stressMultiplier && stressMultiplier > 1.5) return "quality"
-  if (elevatedRecentLoad && subRegime !== "RESEARCH") {
-    if (subRegime === "INIT" && wordCount <= 2 && !hasEvidenceSignal) return "budget"
-    if (/(review|compare|audit|inspect|trace)/i.test(text)) return "audit"
-    return "quality"
-  }
-  if (subRegime === "INIT") {
-    if (wordCount <= 2 && text.length <= 16 && !hasEvidenceSignal) return "budget"
-    return hasEvidenceSignal ? "audit" : "quality"
-  }
-  if (subRegime === "RESEARCH") return "longrun"
-  if (subRegime === "CONVERGING" || subRegime === "CLOSED") return "quality"
-  if (subRegime === "REFINING") return "quality"
-  if (subRegime === "EXPLORING" || subRegime === "DIVERGENT") return hasEvidenceSignal ? "audit" : "quality"
-  return "quality"
-}
-
-export function computeControlVector(
-  state: ContextState,
-  action?: string,
-  optimizationMode?: OptimizationMode,
-): ControlVector {
-  const regime = state.sub_regime || "INIT"
-  const base = REGIME_CONTROL[regime] || DEFAULT_CONTROL
-
-  // Determine effective mode
-  let effectiveMode: OptimizationMode = optimizationMode || "balanced"
-  if (effectiveMode === "auto") {
-    effectiveMode = autoSelectMode(regime, state.latest_stress_multiplier, { state })
-  }
-
-  // Apply mode deltas on top of base (only for non-balanced modes)
-  const delta = effectiveMode !== "balanced" ? (MODE_DELTAS[effectiveMode] || {}) : {}
-
-  const overridden: Omit<ControlVector, "directives"> = {
-    optimization_mode: effectiveMode,
-    enforcement_mode: delta.enforcement_mode ?? base.enforcement_mode,
-    enforcement_reason: delta.enforcement_mode
-      ? `[optimize: ${effectiveMode}] ${describeMode(delta)}`
-      : base.enforcement_reason,
-    flow_mode: delta.flow_mode ?? base.flow_mode,
-    flow_focus: delta.flow_focus ?? base.flow_focus,
-    tdd_mode: delta.tdd_mode ?? base.tdd_mode,
-    tdd_focus: delta.tdd_focus ?? base.tdd_focus,
-    tier_bias: delta.tier_bias ?? base.tier_bias,
-    thinking_mode: delta.thinking_mode ?? base.thinking_mode,
-    stress_multiplier: delta.stress_multiplier ?? base.stress_multiplier,
-    context7_urgency: delta.context7_urgency ?? base.context7_urgency,
-    wbp_verbosity: delta.wbp_verbosity ?? base.wbp_verbosity,
-  }
-
-  const contextPacket = buildContextPacket(overridden, regime, state, action, effectiveMode)
-  const directives = buildDirectives(overridden, regime, state, action, effectiveMode, contextPacket)
-
-  return {
-    ...overridden,
-    context_packet: contextPacket,
-    directives,
-  }
-}
-
-function describeMode(delta: ModeDelta): string {
-  if (delta.tier_bias === "cheap") return "budget mode — max cost savings"
-  if (delta.tier_bias === "brain" && delta.thinking_mode === "full") return "quality mode — max output quality"
-  if (delta.tdd_mode === "quality" && delta.flow_mode === "strict") return "longrun mode — codebase health"
-  if (delta.tier_bias === "medium" && delta.stress_multiplier === 0) return "speed mode — max response speed"
-  return `${delta.tier_bias || "auto"} / ${delta.thinking_mode || "auto"}`
-}
-
-function buildContextPacket(
-  cv: Omit<ControlVector, "context_packet" | "directives">,
-  regime: string,
-  state: ContextState,
-  action?: string,
-  optimizationMode?: OptimizationMode,
-): ContextPacket {
-  const text = String(state.user_text || state.prompt || "")
-  const lower = text.toLowerCase()
-  const stress = Number(state.latest_stress_multiplier ?? cv.stress_multiplier ?? 0)
-  const features = state.features || {}
-  const fileMentions = Number(features.file_mentions ?? 0)
-  const errorSignals = Number(features.error_signals ?? 0)
-  const promptSignals = {
-    error: /bug|error|fail|broken|trace|stack|panic|crash|corrupt|refactor|debug|fix|issue|exception/i.test(lower) || errorSignals > 0.3,
-    forensic: /forensic|investigate|inspect|trace|audit|root cause|reproduce|evidence|logs|stack/i.test(lower) || fileMentions > 0.2,
-    research: regime === "RESEARCH" || optimizationMode === "longrun" || cv.context7_urgency === "required" || /research|study|compare|source|reference|docs/i.test(lower),
-    pivot: Boolean(state.pivot_detected) || /new topic|switch gears|different issue|change topic|pivot/i.test(lower),
-    looping: Boolean(state.is_looping) || regime === "LOOPING",
-    finalizing: regime === "CONVERGING" || regime === "CLOSED" || optimizationMode === "quality",
-  }
-
-  const choose = (): ContextPacketKind => {
-    if (promptSignals.pivot) return "pivot"
-    if (promptSignals.looping || optimizationMode === "speed") return "speed"
-    const evidenceHeavy = promptSignals.error && (errorSignals > 0.4 || fileMentions > 0.2)
-    const docsHeavy = promptSignals.research && /docs|reference|library|api|spec|compare|read|lookup/i.test(lower)
-    const commitHeavy = promptSignals.finalizing && (/commit|ship|release|validate|verify|finalize|close/i.test(lower) || stress > 1.5)
-    if (evidenceHeavy) return "forensic"
-    if (docsHeavy) return "research"
-    if (commitHeavy) return "quality"
-    return "budget"
-  }
-
-  const kind = choose()
-  const packets: Record<ContextPacketKind, ContextPacket> = {
-    budget: {
-      kind: "budget",
-      budget_kb: "1-3",
-      title: "whisper the minimum",
-      summary: "Keep only the smallest useful frame. One decision, one next action, no broad recap.",
-      signals: ["one cheap check", "ask for the single missing detail", "drop everything that does not change the answer"],
-    },
-    speed: {
-      kind: "speed",
-      budget_kb: "1-3",
-      title: "escape the loop",
-      summary: "Use the shortest context that can break repetition. Prefer a fresh angle over more history.",
-      signals: ["summarize the dead end in one line", "offer a new path", "avoid re-injecting prior boilerplate"],
-    },
-    quality: {
-      kind: "quality",
-      budget_kb: "3-10",
-      title: "tighten for correctness",
-      summary: "Carry only the constraints, invariants, and validation steps needed to finish cleanly.",
-      signals: ["check edge cases", "keep the last known good state", "validate before claiming done"],
-    },
-    forensic: {
-      kind: "forensic",
-      budget_kb: "3-10",
-      title: "inspect the evidence",
-      summary: "Load only the artifact trail needed to explain failure: logs, traces, diff, repro steps, and exact scope.",
-      signals: ["prefer concrete evidence", "one hypothesis at a time", "do not expand into unrelated context"],
-    },
-    research: {
-      kind: "research",
-      budget_kb: "10-20",
-      title: "retrieve the right references",
-      summary: "Pull only the specific docs or prior findings relevant to the current decision. Whisper, do not flood.",
-      signals: ["use context7 when required", "summarize only the relevant sources", "stop after the decision is supported"],
-    },
-    pivot: {
-      kind: "pivot",
-      budget_kb: "1-3",
-      title: "acknowledge the turn",
-      summary: "The topic changed. Preserve the new goal and discard stale assumptions before proceeding.",
-      signals: ["confirm the new scope", "reset stale context", "resume with the new target only"],
-    },
-  }
-
-  return packets[kind]
-}
-
-function buildDirectives(
-  cv: Omit<ControlVector, "directives">,
-  regime: string,
-  state: ContextState,
-  action?: string,
-  optimizationMode?: OptimizationMode,
-  contextPacket?: ContextPacket,
-): string[] {
-  const d: string[] = []
-
-  if (cv.enforcement_mode !== "normal") {
-    d.push(
-      `[delegation enforcement: ${cv.enforcement_mode}] ${cv.enforcement_reason}. ` +
-      (cv.enforcement_mode === "relaxed"
-        ? "Write/Edit restrictions are temporarily eased. Proceed with caution."
-        : "ALL write/edit operations must pass strict validation. No exceptions.")
-    )
-  }
-
-  if (cv.flow_mode !== "normal") {
-    const focusNote = cv.flow_focus.length > 0 ? ` Focus rules: ${cv.flow_focus.join(", ")}.` : ""
-    d.push(`[flow: ${cv.flow_mode}] Flow enforcer is in ${cv.flow_mode} mode.${focusNote}`)
-  }
-
-  if (cv.tdd_mode !== "normal") {
-    const focusNote = cv.tdd_focus.length > 0 ? ` Focus: ${cv.tdd_focus.join(", ")}.` : ""
-    d.push(`[tdd: ${cv.tdd_mode}] TDD enforcement is ${cv.tdd_mode}.${focusNote}`)
-  }
-
-  if (cv.tier_bias !== "auto") {
-    d.push(`[tier routing] Route to ${cv.tier_bias} tier for this turn.`)
-  }
-
-  if (contextPacket) {
-    d.push(`[context packet: ${contextPacket.kind} | ${contextPacket.budget_kb} KB] ${contextPacket.title}. ${contextPacket.summary}`)
-    d.push(`[context packet signals] ${contextPacket.signals.join(" | ")}`)
-  }
-
-  if (cv.context7_urgency !== "preferred" && contextPacket?.kind !== "research") {
-    d.push(
-      `[context7] Documentation lookup is ${cv.context7_urgency}. ` +
-      (cv.context7_urgency === "required"
-        ? "Use mcp__context7__* only for the exact library/framework facts needed here."
-        : "context7 tools are available if they change the decision.")
-    )
-  }
-
-  if (cv.wbp_verbosity !== "normal" && contextPacket?.kind !== "speed") {
-    d.push(
-      `[wbp protocol] Delegation output synthesis is ${cv.wbp_verbosity}. ` +
-      (cv.wbp_verbosity === "minimal"
-        ? "Summarize subagent results in 1-2 sentences."
-        : "Provide only the actionable result and the minimum necessary rationale.")
-    )
-  }
-
-  if (cv.thinking_mode !== "auto" && contextPacket?.kind !== "speed") {
-    d.push(
-      `[thinking mode: ${cv.thinking_mode}] Reasoning depth set to ${cv.thinking_mode}. ` +
-      (cv.thinking_mode === "off"
-        ? "Skip extended thinking and stay concise."
-        : "Use extended thinking only when the selected context packet cannot resolve the task.")
-    )
-  }
-
-  if (state.is_looping && state.loop_intervention_level && state.loop_intervention_level !== "none") {
-    const severity = state.loop_intervention_level === "escalated" ? "CRITICAL"
-      : state.loop_intervention_level === "assertive" ? "WARNING" : "NOTICE"
-    d.push(`[loop prevention: ${severity}] The conversation may be looping — try a different approach. (level: ${state.loop_intervention_level})`)
-  }
-
-  if (optimizationMode && optimizationMode !== "balanced") {
-    d.push(`[optimization: ${optimizationMode}] Session optimization mode is "${optimizationMode}". This overrides default per-regime behavior.`)
-  }
-
-  return d
-}
-
-export function buildControlHistoryEntry(
-  turn: number,
-  regime: string,
-  control: ControlVector,
-  reward: number | null = null,
-): Record<string, unknown> {
-  return {
-    turn,
-    regime,
-    control: {
-      enforcement_mode: control.enforcement_mode,
-      flow_mode: control.flow_mode,
-      tdd_mode: control.tdd_mode,
-      tier_bias: control.tier_bias,
-      thinking_mode: control.thinking_mode,
-      stress_multiplier: control.stress_multiplier,
-      context7_urgency: control.context7_urgency,
-      wbp_verbosity: control.wbp_verbosity,
-      context_packet: control.context_packet,
-    },
-    reward,
-  }
-}
-
-export const REGIME_CONTROL_TABLE = REGIME_CONTROL
-export { MODE_DELTAS }

package/lib/patterns.js

@@ -1,150 +0,0 @@
-class PatternStore {
-  constructor() {
-    this.patterns = { friction: {}, routines: {} }
-    this.recentToolEvents = []
-    this.MAX_PATTERNS = 50
-    this.MAX_RECENT = 20
-    this.REPEAT_THRESHOLD = 3
-  }
-
-  recordPattern(kind, key, summary, meta = {}) {
-    const target = kind === "routine" ? this.patterns.routines : this.patterns.friction
-    const now = new Date().toISOString()
-
-    const row = target[key] || {
-      kind,
-      summary,
-      count: 0,
-      sessions: [],
-      firstSeen: now,
-      lastSeen: null,
-      meta: {},
-    }
-
-    row.count = Number(row.count || 0) + 1
-    row.lastSeen = now
-    row.sessions = [...new Set([...(row.sessions || []), meta.sessionId || "unknown"])].slice(-10)
-    if (meta) {
-      row.meta = { ...row.meta, ...meta }
-    }
-
-    target[key] = row
-
-    if (Object.keys(target).length > this.MAX_PATTERNS) {
-      const sorted = Object.entries(target).sort((a, b) => (a[1].lastSeen || "").localeCompare(b[1].lastSeen || ""))
-      const toRemove = sorted.slice(0, Object.keys(target).length - this.MAX_PATTERNS)
-      for (const [k] of toRemove) delete target[k]
-    }
-
-    return row
-  }
-
-  observeToolEvent(toolName, input, output, directory) {
-    const normalized = {
-      tool: toolName,
-      timestamp: Date.now(),
-      target: this.extractTarget(toolName, input),
-      directory,
-    }
-
-    this.recentToolEvents.push(normalized)
-    if (this.recentToolEvents.length > this.MAX_RECENT) {
-      this.recentToolEvents = this.recentToolEvents.slice(-this.MAX_RECENT)
-    }
-
-    const patterns = []
-
-    const repeated = this.detectRepeatedToolCalls()
-    if (repeated) {
-      patterns.push(this.recordPattern("friction", repeated.key, repeated.summary, { tool: toolName }))
-    }
-
-    const verification = this.detectPostEditVerification(output)
-    if (verification) {
-      patterns.push(this.recordPattern(
-        verification.success ? "routine" : "friction",
-        verification.key,
-        verification.summary,
-        { tool: toolName }
-      ))
-    }
-
-    return patterns
-  }
-
-  detectRepeatedToolCalls() {
-    if (this.recentToolEvents.length < this.REPEAT_THRESHOLD) return null
-
-    const recent = this.recentToolEvents.slice(-this.REPEAT_THRESHOLD)
-    const key = `${recent[0].tool}:${recent[0].target}`
-
-    if (recent.every(e => `${e.tool}:${e.target}` === key)) {
-      return {
-        key,
-        summary: `Repeated ${recent[0].tool} on ${recent[0].target} (${this.REPEAT_THRESHOLD}x)`,
-        tool: recent[0].tool,
-        target: recent[0].target,
-      }
-    }
-
-    return null
-  }
-
-  detectPostEditVerification(output) {
-    if (!output) return null
-
-    const isBuild = /build|compile|lint|typecheck/i.test(output)
-    const isSuccess = /success|passed|no errors|0 failed/i.test(output)
-    const isFailure = /error|failed|failed|syntax|cannot find/i.test(output)
-
-    if (isBuild) {
-      return {
-        key: `post_edit_${isSuccess ? "success" : "failure"}`,
-        summary: isSuccess ? "Post-edit verification passed" : "Post-edit verification failed",
-        success: isSuccess,
-      }
-    }
-
-    return null
-  }
-
-  extractTarget(toolName, input) {
-    if (!input) return "unknown"
-    if (typeof input === "string") return input.substring(0, 100)
-    if (typeof input === "object") {
-      return input.filePath || input.file_path || input.command || input.url || JSON.stringify(input).substring(0, 100)
-    }
-    return "unknown"
-  }
-
-  getPatterns(kind = null) {
-    if (kind === "friction") return Object.values(this.patterns.friction)
-    if (kind === "routine") return Object.values(this.patterns.routines)
-    return [...Object.values(this.patterns.friction), ...Object.values(this.patterns.routines)]
-  }
-
-  getLearnedExploratoryWords() {
-    const words = new Set()
-    for (const pattern of Object.values(this.patterns.friction)) {
-      if (pattern.meta?.firstWord && pattern.count >= 2) {
-        words.add(pattern.meta.firstWord)
-      }
-    }
-    return [...words]
-  }
-
-  clear() {
-    this.patterns = { friction: {}, routines: {} }
-    this.recentToolEvents = []
-  }
-
-  toJSON() {
-    return {
-      friction: this.patterns.friction,
-      routines: this.patterns.routines,
-      recent_events: this.recentToolEvents.length,
-    }
-  }
-}
-
-export { PatternStore }