vibeostheog 0.20.7 → 0.20.9

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.20.9
+- feat: hard-block console.log/debug/info in eslint (warn->error)
+- fix: update constants.js OPUS_DISABLE to 1e-10 (dead code, matches TS source)
+- fix: modelCostPerTurn returns FREE_MODEL_TURN_USD for unknown models
+- docs: rename blackbox to VibeBoX and document local fallback
+- docs: dopamine-style README reformat with OPUS->SONNET->HAIKU pricing
+
+
 ## 0.20.7
 - fix: ship compiled OpenCode plugin bundle
 - fix: always show model label in tool.execute.after footer, even with zero savings

package/README.md

@@ -1,18 +1,87 @@
 # vibeOS for OpenCode
 
-> **Alpha Omega Launch** - This release is the first major public launch of vibeOS. See [CHANGELOG.md](CHANGELOG.md) for release notes.
+**Prices validated: May 28, 2026** — verified against OpenRouter `/api/v1/models`
 
-vibeOS is the cost-aware control plane for OpenCode Desktop. It helps individuals and teams keep expensive models focused on strategy, move implementation work to cheaper tiers, and make the resulting savings visible in real time through the live footer and dashboard.
+Cost-aware control plane for OpenCode Desktop. Keeps expensive models on strategy, routes implementation to cheaper tiers, surfaces savings in real time.
 
 For teams, vibeOS adds practical guardrails: delegation enforcement, flow and TDD controls, pattern learning, stress-aware routing, VibeBoX decision tracking, reporting, and remote API protection for the core algorithms.
 
-## What We Offer
+## Delegation Enforcement
+
+Every `write`/`edit`/`notebookedit` on the **brain tier** is intercepted, cost-estimated, and blocked with a visible enforcement note. Work must be delegated to **medium** or **cheap**. This is the primary savings mechanism.
+
+### Per-Turn Cost (700 input + 300 output tokens)
+
+| Tier | Model | Per Turn | Per 100 Turns | vs Opus |
+|------|-------|----------|---------------|---------|
+| Brain | `claude-opus-4-7` | **$0.0330** | **$3.30** | — |
+| Medium | `claude-sonnet-4-6` | **$0.0066** | **$0.66** | saves 80% |
+| Cheap | `claude-haiku-4-5` | **$0.0022** | **$0.22** | saves 93% |
+
+*Source: `src/lib/pricing.ts:279-285`. Conservative estimates — actual OpenRouter live: Opus $0.011, Sonnet $0.0066, Haiku $0.0022 per turn. The plugin over-estimates brain cost so savings are always understated.*
+
+### Savings per Delegation
+
+| Move | Per Turn | 10x | 100x | 1,000x |
+|------|----------|-----|------|--------|
+| Opus → Haiku | $0.0308 | $0.31 | $3.08 | $30.80 |
+| Opus → Sonnet | $0.0264 | $0.26 | $2.64 | $26.40 |
+| Sonnet → Haiku | $0.0044 | $0.04 | $0.44 | $4.40 |
+
+Every blocked brain-tier write/edit saves at least $0.026 (Opus→Sonnet). The running total is tracked in `~/.claude/delegation-state.json` and displayed in the live footer.
+
+---
+
+## Features
+
+| Feature | What it does |
+|---------|-------------|
+| **Delegation enforcement** | Blocks write/edit on brain tier. Routes to medium or cheap. |
+| **Live savings footer** | Model, provider, cumulative savings, cache savings, stress gauge, lock/enforcement tags. |
+| **Web dashboard** | SolidJS SPA with SSE real-time push. Model split, savings, session history, trinity controls. |
+| **Trinity runtime** | `trinity set brain\|medium\|cheap`. Switch tiers mid-session. Change optimization mode. |
+| **Flow enforcer** | Pattern-rule checks on write/edit. Extracts TODO/FIXME into an append-only queue. |
+| **TDD enforcer** | Auto-creates test skeletons for changed source. Strict mode: TODO tests fail. |
+| **Pattern learner** | Tracks recurring struggle/routine patterns per project. |
+| **VibeBoX** | 7 sub-regimes, 11 features per turn, 4 loop intervention levels, PIVOT/SWITCH detection. Auto-mode maps regime to optimization mode. |
+| **Stress-aware routing** | Stress gauge in footer. Stress > 1.5 escalates to quality mode. |
+| **Cache savings** | Separate `cache_savings_usd` tracking for scratchpad cache hits. |
+| **Report tools** | `report-save`, `report-list`, `report-read`, `research-audit`. |
+| **MCP server** | Extended tool capabilities + dashboard serving + SSE push endpoint. |
+| **Remote API** | Fastify server at `api.vibetheog.com`. Token auth with seat/license management. |
+| **Session lock** | `trinity lock on\|off` — freezes model at session start. Resets on restart. |
+
+---
+
+## How It Works
+
+8 hooks into OpenCode Desktop:
+
+| Hook | Purpose |
+|------|---------|
+| `experimental.text.complete` | Appends footer to assistant responses |
+| `experimental.chat.messages.transform` | Injects delegation protocol content |
+| `experimental.chat.system.transform` | Injects cost optimization, stress inoculation, enforcement directives |
+| `tool.execute.before` | Blocks write/edit on brain tier |
+| `tool.execute.after` | Injects delegation UI notes |
+| `message.updated` | Fallback footer for versions without text.complete |
+| `experimental.session.compacting` | Preserves savings state |
+| `shell.env` | Injects `OPENCODE_MODEL_TIER` and `OPENCODE_MODEL` |
+
+---
+
+## Local vs Remote
+
+### Full Local (no token)
+
+Model tier classification, static pricing (~20 models), stress scoring, context budget, turn classification, TDD skeleton gen, flow enforcement, savings ledger, session metrics, reports, footer, dashboard, smart cache, VibeBoX fallback.
+
+### Requires Remote API (api-token)
+
+Bootstrap token exchange, advanced VibeBoX with full session history, dynamic per-prompt delegation, cross-session calibration, live pricing fetch beyond static map.
+
+---
 
-- Model routing that matches the job to the right provider and tier
-- Live savings visibility in chat, the footer, and the web dashboard
-- Separate tracking for delegation savings and cache savings
-- Runtime controls for flow, TDD, model locking, and VibeBoX mode
-- A local fallback path if the remote API is unavailable
 
 ## Local Fallback Mode
 
@@ -30,7 +99,6 @@ Without a token, vibeOS keeps running in local-only mode with bundled algorithms
 ### Requires Remote API
 
 - Bootstrap token exchange (required for initial API setup)
-- Alpha seat issuance is currently uncapped in the admin tooling
 - Advanced VibeBoX decision engine with full session history tracking
 - Dynamic per-prompt delegation decisions (local fallback uses a safe "block all writes on high tier" default)
 - Learned subagent routing patterns across projects (local fallback uses a static exploratory keyword list)
@@ -43,124 +111,139 @@ When the remote API is unreachable, the plugin degrades gracefully to rule-based
 
 ## Install
 
-### OpenCode plugin
-
-1. Register the plugin with the bundled setup command:
-
 ```bash
-npx vibeostheog setup --project
+npx vibeostheog setup --project      # per-project
+npx vibeostheog setup                 # global ~/.config/opencode/
 ```
 
-Use `npx vibeostheog setup` for a global OpenCode install under `~/.config/opencode/`.
+Adds `vibeostheog` to `opencode.json`. Restart OpenCode Desktop.
 
-2. The setup command writes the package name into your OpenCode config. OpenCode installs npm plugins automatically at startup:
+Local dev checkout:
 
 ```json
 {
-  "plugin": [
-    "vibeostheog"
-  ]
+  "plugin": ["/absolute/path/to/theSaver-oc/src/index.js"]
 }
 ```
 
-3. If you keep a local checkout of the plugin, point OpenCode at the built file instead:
+---
+
+## Commands
+
+`trinity help` for full reference. Commands register in the TUI sidebar.
+
+| Command | Effect |
+|---------|--------|
+| `trinity status` | Tier, enforcement, savings, stress, lock state |
+| `trinity set brain\|medium\|cheap` | Switch active model tier |
+| `trinity brain\|medium\|cheap` | Shorthand tier switch |
+| `trinity enable\|disable` | Toggle plugin on/off |
+| `trinity mode budget\|quality\|speed\|longrun\|auto` | Set optimization mode |
+| `trinity thinking full\|brief\|off` | Reasoning depth |
+| `trinity enforce on\|off` | Toggle enforcement |
+| `trinity lock on\|off` | Freeze model for session |
+| `trinity flow on\|off` | Toggle flow enforcer |
+| `trinity flow enforce on\|off` | Toggle auto-extract TODOs |
+| `trinity tdd on\|off\|strict\|quality` | Test skeleton behavior |
+| `trinity rebuild` | Re-detect models from all providers |
+| `trinity project` | Per-project analytics |
+| `trinity patterns` / `trinity patterns clear` | Pattern inspection |
+| `trinity diagnose` | Health check |
+| `trinity VibeBoX on\|off\|status\|reset` | Decision engine control |
+| `trinity repair-state preview\|apply` | Fix state collisions |
+| `trinity guard` | Refresh AGENTS.md / README.md |
+| `trinity api-token <token\|invalidate>` | Manage remote API token |
+| `trinity api-bootstrap-token <token>` | Bootstrap token exchange |
+
+**Report commands**: `report-save`, `report-list`, `report-read`, `research-audit`
+
+---
+
+## Live Footer
 
-```json
-{
-  "plugin": [
-    "/absolute/path/to/theSaver-oc/src/index.js"
-  ]
-}
+```
+— Model: claude-sonnet-4-6 | Provider: Anthropic | $4.82 saved | $1.20 cached | ENFORCE | LOCK | Quality | VIBE —
 ```
 
-Restart OpenCode Desktop after changing the config.
+Provider, model, delegation savings, cache savings, stress gauge (block chars), lock/enforcement tags, optimization mode. Persisted in `~/.claude/delegation-state.json`.
 
-The package also exposes `vibeostheog/server` and `vibeostheog/tui` for integrations that need the MCP server or sidebar plugin entrypoints directly.
+---
 
-## Common Npm Commands
+## Architecture
 
-```bash
-npm install
-npm run build
-npm run typecheck
-npm test
-npm run release:patch
-```
+### Plugin Source
+
+Single-file runtime `src/index.js` (5529+ lines). TypeScript source of truth at `src/vibeOS-lib/*.ts` and `src/utils/*.ts`. Build: `npm run build` (tsc + esbuild bundle + deploy script).
+
+### State Files (`~/.claude/`)
+
+| File | Purpose |
+|------|---------|
+| `delegation-state.json` | Sessions, warns, cache hits, lifetime totals |
+| `model-tiers.json` | brain/medium/cheap model IDs |
+| `project-states.json` | Per-project memory, analytics, report references |
+| `reports/` | Saved report JSON files |
+| `savings-ledger.jsonl` | Append-only savings and credit event log |
+| `global-learning.json` | Cross-project pattern learning, pricing hints |
+| `model-pricing-cache.json` | Cached pricing by model ID |
+| `active-jobs.json` | In-flight delegation records |
+| `VibeBoX-state.json` | Per-project resolution tracker, session outcomes |
+| `.flow-todo-queue.jsonl` | Flow enforcer TODO queue |
+| `.flow-dedup-keys.json` | Deduplication set for flow TODO |
+| `.enforcement-cooldown.jsonl` | Per-tool cooldown for warn coalescing |
+
+### VibeBoX Decision Engine
+
+
+7 sub-regimes (INIT, DIVERGENT, EXPLORING, REFINING, CONVERGING, CLOSED, LOOPING). Classification via entropy trends, action consistency, feature contradiction, embedding drift. 11 derived features per turn. 4 loop intervention levels. PIVOT/SWITCH detection. Outcome tracking from satisfaction signals.
+
+
+Regime→mode mapping via `syncControlSettings()`:
+
+| Regime | Mode | Enforce | Flow | TDD | Tier | Think |
+|--------|------|---------|------|-----|------|-------|
+| INIT / DIVERGENT / EXPLORING / REFINING | budget | relaxed | audit | lazy | cheap | off |
+| CONVERGING / CLOSED | quality | strict | strict | quality | brain | full |
+| LOOPING | speed | relaxed | audit | lazy | medium | off |
+
+Stress > 1.5 escalates any regime to quality.
+
+### Remote API Server
+
+`src/vibeOS-api-server/` — Fastify + SQLite at `api.vibetheog.com`. Endpoints: delegation check, tier routing, stress scoring, VibeBoX analysis/calibration, TDD skeleton gen, pattern observation, pricing fetch, context compression. Auth via `VIBEOS_API_TOKEN`. Client: `src/vibeOS-api-server/client.js` with automatic local fallback.
+
+### Dashboard
+
+SolidJS SPA at `src/dashboard/`. Build: `npm run build:dashboard` (vite). Served by MCP server or standalone. SSE `/events` for real-time push (model split, savings, session history, stress, VibeBoX state).
+
+---
+
+## Environment Variables
 
-`npm run build` compiles `src/index.ts` to `src/index.js` for the local checkout. `npm run typecheck` validates the TypeScript sources without emitting files.
-
-## Core Controls
-
-`trinity` is an OpenCode plugin command. Run it from inside OpenCode, not from a normal terminal shell. Use `trinity help` for the full command list. The bundled TUI plugin also registers `trinity` and the common slot actions in OpenCode's command palette.
-
-The most common controls are:
-
-- `trinity status` - show current tier, enforcement, savings, stress, and lock state
-- `trinity set brain|medium|cheap` - switch the active tier
-- `trinity brain|medium|cheap` - shorthand tier switch
-- `trinity rebuild` - re-detect available models and repopulate slots
-- `trinity enable` / `trinity disable` - toggle the plugin on or off
-- `trinity mode budget|quality|speed|longrun|auto` - change the optimization mode
-- `trinity thinking full|brief|off` - change reasoning depth
-- `trinity enforce on|off` - control delegation enforcement
-- `trinity lock on|off` - freeze the active model for the session
-- `trinity flow on|off` and `trinity flow enforce on|off` - manage flow checks
-- `trinity tdd on|off`, `trinity tdd strict on|off`, `trinity tdd quality on|off` - manage test skeleton behavior
-- `trinity project` - open project analytics
-- `trinity patterns` / `trinity patterns clear` - inspect or reset learned patterns
-- `trinity diagnose` - run a health check
-- `trinity repair-state preview|apply` - fix state fingerprint collisions
-- `trinity VibeBoX on|off|status|reset` - control the decision engine
-- `trinity guard` - refresh AGENTS.md and README.md checks
-- `trinity api-token <token|invalidate>` - update the remote API token, or invalidate the current alpha token and disable remote API
-- `trinity api-bootstrap-token <token>` - store an alpha bootstrap token and exchange it for a normal API token on alpha builds
-
-Additional reporting commands:
-
-- `report-save`
-- `report-list`
-- `report-read`
-- `research-audit`
-
-## Savings And Footer
-
-The footer shows:
-
-- the active provider/model in use for the current run
-- cumulative delegation savings
-- cache savings
-- stress level
-- lock and enforcement tags
-
-Savings are persisted in `~/.claude/delegation-state.json`.
-
-## Configuration
-
-| Variable | Default | Purpose |
-|---|---|---|
-| `VIBEOS_API_URL` | `https://api.vibetheog.com` | Remote API server URL |
-| `VIBEOS_API_TOKEN` | unset | vos_8d73804b13bb46711b9a47f036dba7b4d026fd9583d96960e663716e62815a69 |
-| `VIBEOS_API_DISABLED` | `false` | Set to `true` to invalidate the embedded alpha token and keep remote API off until re-enabled |
-| `VIBEOS_API_BOOTSTRAP_TOKEN` | unset | Alpha bootstrap token for initial auth exchange |
-| `VIBEOS_API_ENABLED` | `true` | Set to `false` for local-only mode |
+| Variable | Default | Effect |
+|----------|---------|--------|
+| `VIBEOS_API_URL` | `https://api.vibetheog.com` | Remote API base URL |
+| `VIBEOS_API_TOKEN` | unset | Remote API auth |
+| `VIBEOS_API_DISABLED` | `false` | Invalidate alpha token |
+| `VIBEOS_API_BOOTSTRAP_TOKEN` | unset | Bootstrap exchange |
+| `VIBEOS_API_ENABLED` | `true` | Set `false` for local-only |
 | `CLAUDE_CREDIT_PERCENT` | `100` | Credit override |
-| `CLAUDE_CONTEXT7_AVAILABLE` | unset | Enables context7 optimization |
-| `CLAUDE_SCRATCHPAD_MAX_AGE_SEC` | `86400` | Scratchpad cache lifetime |
+| `CLAUDE_CONTEXT7_AVAILABLE` | unset | Context7 optimization |
 | `VIBEOS_MCP_PORT` | `3001` | MCP server port |
 
-Without a token, vibeOS keeps running in local-only mode with bundled algorithms.
+---
 
 ## Troubleshooting
 
-- If the plugin does not appear, confirm the OpenCode config entry, then restart OpenCode Desktop.
-- If the model will not switch, run `trinity rebuild` and then `trinity set brain|medium|cheap`.
-- If writes or edits are blocked, that is usually delegation enforcement working as intended on the brain tier.
-- If the footer is missing, check that the plugin is enabled and that the current OpenCode session is receiving assistant completions.
-- If the remote API is down or the token is invalid, use `trinity api-token <token>` or `trinity api-bootstrap-token <token>` on alpha builds. Use `trinity api-token invalidate` when you want to intentionally revoke the alpha token and stay local-only.
-- If the dashboard does not load, rebuild the plugin with `npm run build` and restart OpenCode.
-- If state or config looks inconsistent, run `trinity diagnose` and `trinity guard`.
+| Symptom | Fix |
+|---------|-----|
+| Plugin not loading | Check `opencode.json` entry. Restart Desktop. |
+| Model won't switch | `trinity rebuild` then `trinity set brain\|medium\|cheap` |
+| Writes/edits blocked | Enforcement active — delegate to cheap tier |
+| No footer visible | Verify plugin enabled, completions running |
+| Dashboard blank | `npm run build` then restart |
+| State looks wrong | `trinity diagnose` then `trinity repair-state preview` |
 
-## Notes
+---
 
-- `trinity help` is the canonical command reference.
-- The README stays intentionally high level so the command details can follow the code without a rewrite.
+*`trinity help` is the canonical command reference. This README stays high-level so command details follow the code without a rewrite.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeostheog",
-  "version": "0.20.7",
+  "version": "0.20.9",
   "description": "Cost-aware delegation enforcer for OpenCode. Tracks model usage, routes Task subagents to cheaper tiers, surfaces cumulative savings in chat. Includes research audit, reporting framework, project memory, progressive scratchpad decadence, and trinity CLI for brain/medium/cheap slot switching.",
   "scripts": {
     "release": "node scripts/release.mjs",

package/src/lib/constants.js

@@ -6,7 +6,7 @@ export const SAVE_EST = {
     SOFT_QUOTA: 0.0001,
     // DeepSeek cache: (0.14 - 0.0028)/1M * ~1000 tokens = 0.00014
     CONTEXT7: 0.00014,
-    OPUS_DISABLE: 0.03,
+    OPUS_DISABLE: 1e-10,
 };
 export const WARN_ON_DIRECT = new Set(["write", "edit", "notebookedit"]);
 export const SOFT_QUOTA = new Set(["bash", "glob", "grep", "read", "webfetch", "websearch"]);

package/src/lib/hooks/session-compact.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { readFileSync, existsSync } from "node:fs";
-import { loadSelection, getSessionScratchpadDir, getSessionIndexPath } from "../state.js";
+import { loadSelection, _OC_SID, updateState, getSessionScratchpadDir, getSessionIndexPath } from "../state.js";
 import { getTurnCounter } from "../turn-classify.js";
 export const onSessionCompacting = async (_input, output) => {
     if (!loadSelection().enabled)
@@ -57,6 +57,24 @@ export const onSessionCompacting = async (_input, output) => {
         else if (output) {
             output.context = contextEntries;
         }
+        // Persist last_compacted_at so telemetry reflects actual compaction
+        if (needsCompact && output) {
+            try {
+                updateState((state) => {
+                    const now = new Date().toISOString();
+                    state.sessions ??= {};
+                    const sid = _OC_SID;
+                    state.sessions[sid] ??= {};
+                    state.sessions[sid].telemetry ??= {};
+                    state.sessions[sid].telemetry.last_compacted_at = now;
+                    state.lifetime ??= {};
+                    state.lifetime.telemetry ??= {};
+                    state.lifetime.telemetry.last_compacted_at = now;
+                    return state;
+                });
+            }
+            catch { }
+        }
     }
     catch (err) {
         console.error(`[vibeOS] session.compacting failed: ${err.message}`);

package/src/lib/hooks/tool-execute.js

@@ -1,7 +1,8 @@
 // @ts-nocheck
 import { writeFileSync, appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, dirname, basename } from "node:path";
-import { currentTier, currentModel, setCurrentModel, setCurrentTier, _OC_SID, _modelLocked, loadSelection, readLifetimeSavings, recordCacheSaving, recordMissedContext7, getScratchpadHit, recordScratchpadObservation, recordPrivacyTelemetry, updateState, SAVINGS_LEDGER_FILE, CONTEXT7_INSTALL_FLAG, SOFT_QUOTA_LIMIT, upsertTodo, ML_ENABLED, _mlGraph, _cacheDb, _mlSavePending, ML_CONFIDENCE_THRESHOLD, setMlSavePending, saveMLState, SCRATCHPAD_TOOLS, applyDecadence, } from "../state.js";
+import { createHash } from "node:crypto";
+import { currentTier, currentModel, setCurrentModel, setCurrentTier, _OC_SID, _modelLocked, loadSelection, readLifetimeSavings, recordCacheSaving, recordMissedContext7, getScratchpadHit, recordScratchpadObservation, recordPrivacyTelemetry, updateState, getSessionScratchpadDir, ensureSessionScratchpadDirs, SAVINGS_LEDGER_FILE, CONTEXT7_INSTALL_FLAG, SOFT_QUOTA_LIMIT, upsertTodo, ML_ENABLED, _mlGraph, _cacheDb, _mlSavePending, ML_CONFIDENCE_THRESHOLD, setMlSavePending, saveMLState, SCRATCHPAD_TOOLS, SCRATCHPAD_GLOBAL_DIR, TOOL_NAME_NORMALIZE, stableJson, applyDecadence, } from "../state.js";
 import { classify, modelCostPerTurn, isModelFree, detectContext7, isDocsTarget, shortModelName, formatUsd, _refreshModel, readConfig, resolveDisplayModelId, TRINITY_CHEAP, TRINITY_MEDIUM, trendDisplay, modelToSlotLabel, resolveExecutionIdentity, formatProviderName, formatQualityName, } from "../pricing.js";
 import { latestUserIntent } from "./chat-transform.js";
 import { scoreStress, extractFirstWordFromArgs, shouldLogWarn, isUserAskingForTests, resolveEnforcementMode, getLearnedExploratoryWords, noteTaskRoutingLearning, } from "../turn-classify.js";
@@ -272,8 +273,46 @@ export const onToolExecuteBefore = async (input, output) => {
                     recordCacheStats(_cacheDb, t, !!hit, hit ? _cacheSave : 0);
                     if (!hit) {
                         const prediction = predictCacheHit(_cacheDb, t, promptText);
-                        if (prediction.shouldWarm && prediction.confidence >= 0.6 && DEBUG_INTERNALS) {
-                            console.error(`[vibeOS] 🔮 Smart cache: ${t} may benefit from caching — ${prediction.reason} (conf: ${(prediction.confidence * 100).toFixed(0)}%)`);
+                        if (prediction.shouldWarm && prediction.confidence >= 0.6 && prediction.similarEntries.length > 0) {
+                            try {
+                                const titleCase = TOOL_NAME_NORMALIZE[t];
+                                if (titleCase) {
+                                    const argsJson = stableJson(args ?? inArgs ?? {});
+                                    const curHash = createHash("sha256").update(`${titleCase}\n${argsJson}\n`).digest("hex").slice(0, 16);
+                                    const sessionDir = getSessionScratchpadDir();
+                                    const globalDir = SCRATCHPAD_GLOBAL_DIR;
+                                    const ptrPath = join(sessionDir, `${curHash}.ptr`);
+                                    if (!existsSync(ptrPath)) {
+                                        for (const similar of prediction.similarEntries) {
+                                            const targetHash = similar.entry.hash;
+                                            if (targetHash.length < 16)
+                                                continue;
+                                            const cachedFile = join(sessionDir, `${targetHash}.txt`);
+                                            const globalFile = join(globalDir, `${targetHash}.txt`);
+                                            if (existsSync(cachedFile) || existsSync(globalFile)) {
+                                                ensureSessionScratchpadDirs();
+                                                writeFileSync(ptrPath, JSON.stringify({
+                                                    contentHash: targetHash,
+                                                    tool: titleCase,
+                                                    warmed: true,
+                                                    at: new Date().toISOString(),
+                                                    confidence: prediction.confidence,
+                                                    reason: prediction.reason,
+                                                }));
+                                                if (DEBUG_INTERNALS) {
+                                                    console.error(`[vibeOS] 🔮 Smart cache: warmed ${t} → ${targetHash.slice(0, 8)} (conf: ${(prediction.confidence * 100).toFixed(0)}%)`);
+                                                }
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            catch (warmErr) {
+                                if (DEBUG_INTERNALS) {
+                                    console.error(`[vibeOS] Smart cache warming error: ${warmErr.message}`);
+                                }
+                            }
                         }
                     }
                 }
@@ -420,12 +459,10 @@ export const onToolExecuteBefore = async (input, output) => {
     const _workerModel = TRINITY_CHEAP || TRINITY_MEDIUM || null;
     const _workerCost = _workerModel ? (modelCostPerTurn(_workerModel) ?? 0) : 0;
     // Keep precision high to avoid dropping tiny but real per-event savings to zero.
-    const _rawEdit = _brainCost !== null
-        ? Math.max(0, _brainCost - _workerCost)
-        : SAVE_EST.WRITE_EDIT;
+    const _rawEdit = Math.max(0, _brainCost - _workerCost);
     const _estEdit = Math.max(_rawEdit, SAVE_EST.WRITE_EDIT * 0.1);
-    const _estOpus = _brainCost !== null ? Math.max(_brainCost, _estEdit) : SAVE_EST.OPUS_DISABLE;
-    const _estC7 = _brainCost !== null ? Math.max(_brainCost, SAVE_EST.CONTEXT7) : SAVE_EST.CONTEXT7;
+    const _estOpus = Math.max(_brainCost, _estEdit);
+    const _estC7 = Math.max(_brainCost, SAVE_EST.CONTEXT7);
     const _tierWord = currentTier === "high" ? "Brain" : currentTier === "mid" ? "Medium" : "Budget";
     const _firstWord = extractFirstWordFromArgs(t, args || inArgs);
     const sel = loadSelection();

package/src/lib/pricing.js

@@ -521,7 +521,7 @@ export function modelCostPerTurn(model) {
     }
     // Log unknown models so we can add entries
     console.error(`[vibeOS] modelCostPerTurn: unknown model '${model}' (normalized: '${key}') — add to MODEL_USD_PER_TURN`);
-    return null; // unknown — callers fall back to SAVE_EST constants
+    return FREE_MODEL_TURN_USD;
 }
 export function isModelFree(model) {
     if (!model || typeof model !== "string")
@@ -531,7 +531,7 @@ export function isModelFree(model) {
     if (FREE_MODELS.has(normalizeModelId(model)))
         return true;
     const cost = modelCostPerTurn(model);
-    return cost !== null && cost <= FREE_MODEL_TURN_USD;
+    return cost <= FREE_MODEL_TURN_USD;
 }
 // Context7 detection — scan known config files for the string "context7".
 // Cheap (one-time at module load); falsy → docs nudge stays dormant.

package/src/vibeOS-lib/blackbox/index.js

@@ -9,3 +9,5 @@ export { ResolutionTracker } from "./resolution-tracker.js";
 export { ExposureModel } from "./exposure-model.js";
 export { ACTION_TARGET, ACTION_TYPE, FALLBACK_PLANS, ACTION_SUGGESTIONS, CURIOSITY_PROMPTS, } from "./crew-constants.js";
 export { computeControlVector, buildControlHistoryEntry, REGIME_CONTROL_TABLE, } from "./meta-controller.js";
+export { vibemaxSelectMode, vibemaxPipeline, predictVibeMaX, trainVibeMaXModelFromTelemetry, getVibeMaXModelMeta, resetVibeMaXPipeline } from "./vibemax.js";
+export { PivotCache } from "./pivot-cache.js";

package/src/vibeOS-lib/blackbox/meta-controller.js

@@ -160,6 +160,21 @@ const MODE_DELTAS = {
         api_enrichment: true,
         outcome_detection: true,
     },
+    vibemax: {
+        tier_bias: "medium",
+        thinking_mode: "full",
+        tdd_mode: "quality",
+        tdd_focus: ["skeleton-on-write", "assertion-check", "edge-cases"],
+        flow_mode: "strict",
+        flow_focus: ["write-edit-check", "no-lgtm", "check-debug-artifacts"],
+        enforcement_mode: "strict",
+        wbp_verbosity: "normal",
+        context7_urgency: "required",
+        stress_multiplier: 1.0,
+        loop_threshold: 0.6,
+        api_enrichment: true,
+        outcome_detection: true,
+    },
 };
 export function autoSelectMode(subRegime, stressMultiplier) {
     if (subRegime === "CONVERGING" || subRegime === "CLOSED")
@@ -174,10 +189,15 @@ export function computeControlVector(state, action, optimizationMode) {
     const regime = state.sub_regime || "INIT";
     const base = REGIME_CONTROL[regime] || DEFAULT_CONTROL;
     // Determine effective mode
-    let effectiveMode = optimizationMode || "balanced";
+    let effectiveMode = optimizationMode || "vibemax";
     if (effectiveMode === "auto") {
         effectiveMode = autoSelectMode(regime, state.latest_stress_multiplier);
     }
+    if (effectiveMode === "vibemax") {
+        const baseMode = autoSelectMode(regime, state.latest_stress_multiplier);
+        const vibemaxQuality = ["quality", "longrun", "audit"];
+        effectiveMode = vibemaxQuality.includes(baseMode) ? "vibemax" : "budget";
+    }
     // Apply mode deltas on top of base (only for non-balanced modes)
     const delta = effectiveMode !== "balanced" ? (MODE_DELTAS[effectiveMode] || {}) : {};
     const overridden = {
@@ -211,6 +231,8 @@ function describeMode(delta) {
         return "longrun mode — codebase health";
     if (delta.tier_bias === "medium" && delta.stress_multiplier === 0)
         return "speed mode — max response speed";
+    if (delta.tier_bias === "medium" && delta.loop_threshold === 0.6)
+        return "vibemax mode — ml-optimized budget: 97% quality at 37% cost";
     return `${delta.tier_bias || "auto"} / ${delta.thinking_mode || "auto"}`;
 }
 function buildDirectives(cv, regime, state, action, optimizationMode) {

package/src/vibeOS-lib/blackbox/pivot-cache.js

@@ -0,0 +1,175 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+export class PivotCache {
+    store;
+    baseDir;
+    pivotSequence;
+    currentWorkflow;
+    lastTokens;
+    constructor(baseDir) {
+        this.baseDir = baseDir || join(homedir(), ".claude");
+        this.pivotSequence = [];
+        this.currentWorkflow = null;
+        this.lastTokens = new Set();
+        this.store = this._load();
+    }
+    _storePath() {
+        return join(this.baseDir, ".vibeos-pivot-cache.json");
+    }
+    _load() {
+        try {
+            const p = this._storePath();
+            if (existsSync(p)) {
+                return JSON.parse(readFileSync(p, "utf-8"));
+            }
+        }
+        catch { /* ignore */ }
+        return { pivots: {}, version: 3 };
+    }
+    save() {
+        try {
+            const p = this._storePath();
+            const dir = dirname(p);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(p, JSON.stringify(this.store, null, 2), "utf-8");
+        }
+        catch { /* ignore */ }
+    }
+    tokenize(text) {
+        const tl = text.toLowerCase();
+        const tokens = new Set();
+        if (/deploy|redeploy|bundle|release|npm/.test(tl))
+            tokens.add("deploy");
+        if (/(?:\bgit\b|\bcommit\b|\bpush\b|\bmerge\b|\bpr\b|\bpull\b|\brebase\b)/.test(tl))
+            tokens.add("git");
+        if (/budget|cost|price|pricing/.test(tl))
+            tokens.add("pricing");
+        if (/debug|fix|bug|error|broken/.test(tl))
+            tokens.add("debug");
+        if (/context|cache|pivot|compression/.test(tl))
+            tokens.add("caching");
+        if (/test|experiment|verify|validate/.test(tl))
+            tokens.add("test");
+        if (/config|token|api|secret|env|auth/.test(tl))
+            tokens.add("config");
+        if (/create|add|implement|build|write/.test(tl))
+            tokens.add("create");
+        if (/read|check|see|show|status|list/.test(tl))
+            tokens.add("inspect");
+        if (/refactor|clean|rename|move|restructure/.test(tl))
+            tokens.add("refactor");
+        if (tokens.size === 0)
+            tokens.add("misc");
+        return tokens;
+    }
+    detectPivot(current, previous, timeGap = 0) {
+        const cur = this.tokenize(current);
+        const prev = this.tokenize(previous);
+        const inter = new Set([...cur].filter(x => prev.has(x)));
+        const union = new Set([...cur, ...prev]);
+        const sim = union.size === 0 ? 1 : inter.size / union.size;
+        const timePenalty = Math.min(0.3, timeGap / 600);
+        const adjusted = sim - timePenalty;
+        return { isPivot: adjusted < 0.3, similarity: Math.round(adjusted * 1000) / 1000 };
+    }
+    snapshot(workflowId, context) {
+        const entry = {
+            id: workflowId,
+            captured_at: new Date().toISOString(),
+            tokens: context.tokens || [],
+            intent: context.intent || "",
+            decisions: context.decisions || [],
+            files: context.files || [],
+            code_snippets: context.code_snippets || [],
+            blockers: context.blockers || [],
+            access_count: 0,
+            useful_sections: ["decisions", "files"],
+            skip_sections: [],
+        };
+        this.store.pivots[workflowId] = entry;
+        if (!this.pivotSequence.includes(workflowId)) {
+            this.pivotSequence.push(workflowId);
+        }
+        this.save();
+    }
+    detectPivotBack(tokens, confidenceThreshold = 0.5) {
+        if (this.pivotSequence.length < 2) {
+            return { matchedId: null, confidence: 0, reason: "not_enough_pivots" };
+        }
+        const candidates = [];
+        for (let i = 0; i < this.pivotSequence.length; i++) {
+            const pid = this.pivotSequence[i];
+            if (pid === this.pivotSequence[this.pivotSequence.length - 1])
+                continue;
+            const entry = this.store.pivots[pid];
+            if (!entry)
+                continue;
+            const cached = new Set(entry.tokens);
+            if (cached.size === 0)
+                continue;
+            const inter = new Set([...tokens].filter(x => cached.has(x)));
+            const union = new Set([...tokens, ...cached]);
+            const jaccard = union.size === 0 ? 0 : inter.size / union.size;
+            const exactBonus = tokens.size === cached.size && [...tokens].every(t => cached.has(t)) ? 0.2 : 0;
+            const recency = i / Math.max(this.pivotSequence.length, 1);
+            const accessBonus = Math.min(0.1, (entry.access_count || 0) * 0.02);
+            const confidence = jaccard + exactBonus + recency * 0.1 + accessBonus;
+            candidates.push([pid, confidence, jaccard]);
+        }
+        if (candidates.length === 0) {
+            return { matchedId: null, confidence: 0, reason: "no_candidates" };
+        }
+        candidates.sort((a, b) => b[1] - a[1]);
+        const [bestId, bestConf] = candidates[0];
+        if (bestConf < confidenceThreshold) {
+            return { matchedId: null, confidence: bestConf, reason: "low_confidence" };
+        }
+        if (this.store.pivots[bestId]) {
+            this.store.pivots[bestId].access_count = (this.store.pivots[bestId].access_count || 0) + 1;
+        }
+        this.save();
+        return { matchedId: bestId, confidence: bestConf, reason: "matched" };
+    }
+    buildInjection(workflowId, maxSections = 3) {
+        const entry = this.store.pivots[workflowId];
+        if (!entry)
+            return "";
+        const parts = [];
+        const skip = new Set(entry.skip_sections);
+        if (!skip.has("decisions") && entry.decisions.length > 0) {
+            parts.push(`[${workflowId}] ${entry.decisions.slice(0, 3).join(" | ")}`);
+        }
+        if (entry.blockers.length > 0 && !skip.has("blockers")) {
+            parts.push(`[blockers] ${entry.blockers.slice(0, 2).join(" | ")}`);
+        }
+        if (entry.code_snippets.length > 0 && entry.useful_sections.includes("code") && !skip.has("code")) {
+            parts.push(`[code] ${entry.code_snippets.slice(0, 2).join(" | ")}`);
+        }
+        return parts.join("\n");
+    }
+    learn(workflowId, usedSections, unusedSections) {
+        const entry = this.store.pivots[workflowId];
+        if (!entry)
+            return;
+        for (const s of usedSections) {
+            if (!entry.useful_sections.includes(s))
+                entry.useful_sections.push(s);
+        }
+        for (const s of unusedSections) {
+            if (!entry.skip_sections.includes(s) && (entry.access_count || 0) > 3) {
+                entry.skip_sections.push(s);
+            }
+        }
+        this.save();
+    }
+    resetSequence() {
+        this.pivotSequence = [];
+        this.currentWorkflow = null;
+        this.lastTokens = new Set();
+    }
+    getRecentPivots(n = 5) {
+        return this.pivotSequence.slice(-n);
+    }
+}

package/src/vibeOS-lib/blackbox/vibemax.js

@@ -0,0 +1,271 @@
+// @ts-nocheck
+import { autoSelectMode } from "./meta-controller.js";
+import { PivotCache } from "./pivot-cache.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MODEL_PATH = process.env.VIBEOS_VIBEMAX_MODEL_PATH || resolve(__dirname, "..", "..", "..", "data", "vibemax-model.json");
+const PRIORITY = { budget: 0, audit: 1, speed: 2, longrun: 3, quality: 4 };
+function fallback(sr, text) {
+    if (sr === "LOOPING")
+        return "speed";
+    const t = String(text || "").toLowerCase();
+    if (sr === "INIT" && t.length <= 42 && !/[\.\/\\]/.test(t))
+        return "budget";
+    return "quality";
+}
+// PRNG
+function rng(seed) {
+    let s = seed | 0;
+    return () => { s |= 0; s = s + 0x6D2B79F5 | 0; let t = Math.imul(s ^ s >>> 15, 1 | s); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; };
+}
+function gini(samples, label) {
+    return 1 - samples.filter(s => s.label === label).length ** 2 / samples.length ** 2;
+}
+function buildTree(samples, classes, depth, maxDepth, minLeaf, rngFn) {
+    if (samples.length <= minLeaf || depth >= maxDepth || new Set(samples.map(s => s.label)).size === 1) {
+        const counts = Object.fromEntries(classes.map(c => [c, 0]));
+        for (const s of samples)
+            counts[s.label]++;
+        const total = samples.length || 1;
+        return { prediction: classes.reduce((a, b) => counts[a] > counts[b] ? a : b), probs: classes.map(c => counts[c] / total) };
+    }
+    const nFeats = samples[0]?.features?.length || 1;
+    const featSample = Math.max(2, Math.min(nFeats, Math.floor(Math.sqrt(nFeats)) + 1));
+    const cols = new Set();
+    while (cols.size < featSample)
+        cols.add(Math.floor(rngFn() * nFeats));
+    let bestG = 0, bestC = -1, bestV = 0;
+    for (const c of cols) {
+        const vals = [...new Set(samples.map(s => s.features[c]))].sort((a, b) => a - b);
+        for (const v of vals) {
+            const l = samples.filter(s => s.features[c] <= v);
+            const r = samples.filter(s => s.features[c] > v);
+            if (l.length < minLeaf || r.length < minLeaf)
+                continue;
+            const gParent = classes.reduce((sum, cl) => sum + gini(samples, cl), 0);
+            const gChild = (l.length / samples.length) * classes.reduce((sum, cl) => sum + gini(l, cl), 0) + (r.length / samples.length) * classes.reduce((sum, cl) => sum + gini(r, cl), 0);
+            const gain = gParent - gChild;
+            if (gain > bestG) {
+                bestG = gain;
+                bestC = c;
+                bestV = v;
+            }
+        }
+    }
+    if (bestC === -1 || bestG <= 0) {
+        const counts = Object.fromEntries(classes.map(c => [c, 0]));
+        for (const s of samples)
+            counts[s.label]++;
+        const total = samples.length || 1;
+        return { prediction: classes.reduce((a, b) => counts[a] > counts[b] ? a : b), probs: classes.map(c => counts[c] / total) };
+    }
+    return { column: bestC, value: bestV, left: buildTree(samples.filter(s => s.features[bestC] <= bestV), classes, depth + 1, maxDepth, minLeaf, rngFn), right: buildTree(samples.filter(s => s.features[bestC] > bestV), classes, depth + 1, maxDepth, minLeaf, rngFn) };
+}
+function predictTree(tree, features) {
+    if (tree.prediction)
+        return tree;
+    return features[tree.column] <= tree.value ? predictTree(tree.left, features) : predictTree(tree.right, features);
+}
+const VIBEMAX_CFG = { tier: "medium", thinking: "full", tdd: "quality", flow: "strict", enforcement: "strict", wbp: "normal", c7: "required", kp: [3, 6], tc: 0.3, amode: "plan" };
+const BUDGET_CFG = { tier: "cheap", thinking: "off", tdd: "normal", flow: "audit", enforcement: "relaxed", wbp: "minimal", c7: "skippable", kp: [1, 3], tc: 0.1, amode: "build" };
+const VIBEMAX_MAP = { quality: "optimized", longrun: "optimized", audit: "optimized", speed: "budget", budget: "budget" };
+// PivotCache instance
+let pivotCache = null;
+function getPivotCache() {
+    if (!pivotCache)
+        pivotCache = new PivotCache();
+    return pivotCache;
+}
+let prevMessage = "";
+export function resetVibeMaXPipeline() {
+    prevMessage = "";
+    if (pivotCache)
+        pivotCache.resetSequence();
+}
+export function vibemaxSelectMode(input = {}) {
+    const stress = Number(input.stress_multiplier || input.stress || 0);
+    const pm = autoSelectMode(input.sub_regime, stress) || fallback(input.sub_regime, input.user_text || input.prompt || "");
+    const vm = VIBEMAX_MAP[pm] || "optimized";
+    if (vm === "budget") {
+        return { mode: "budget", source: "vibemax", source_prediction: pm, confidence: 0, auto_result: null, ...BUDGET_CFG, cost: 0.1 };
+    }
+    const cfg = loadVibeMaXModel()?.config || { think: "full", wbp: "normal", kp: [3, 6] };
+    const text = input.user_text || input.prompt || "";
+    // PivotCache: detect if returning to a cached workflow
+    const pc = getPivotCache();
+    const tokens = pc.tokenize(text);
+    const pivotBack = text && tokens.size > 0 ? pc.detectPivotBack(tokens, 0.5) : { matchedId: null, confidence: 0, reason: "no_text" };
+    const isPivotBack = pivotBack.matchedId !== null;
+    const think = isPivotBack ? "brief" : (cfg.think || "full");
+    const injection = isPivotBack ? pc.buildInjection(pivotBack.matchedId) : "";
+    return {
+        mode: "vibemax", source: "vibemax", source_prediction: pm, confidence: 0,
+        auto_result: null, tier: "medium", thinking: think, tdd: "quality", flow: "strict",
+        enforcement: "strict", wbp: cfg.wbp || "normal", c7: "required", kp: cfg.kp || [3, 6],
+        tc: 0.3, amode: "plan", cost: 0.3,
+        pivot: isPivotBack ? { matchedId: pivotBack.matchedId, confidence: pivotBack.confidence, injection } : null,
+    };
+}
+export function vibemaxPipeline(input = {}) {
+    const text = input.user_text || input.prompt || "";
+    const pc = getPivotCache();
+    // Detect pivot from previous message
+    const isPivot = prevMessage && text ? pc.detectPivot(text, prevMessage) : { isPivot: false, similarity: 1 };
+    // If pivot: snapshot previous workflow before switching
+    if (isPivot.isPivot && prevMessage) {
+        const prevTokens = pc.tokenize(prevMessage);
+        const prevId = "wf-" + Date.now();
+        pc.snapshot(prevId, {
+            tokens: [...prevTokens],
+            intent: prevMessage.substring(0, 60),
+            decisions: ["previous workflow captured at pivot point"],
+            files: [], code_snippets: [], blockers: [],
+        });
+    }
+    const result = vibemaxSelectMode(input);
+    if (text)
+        prevMessage = text;
+    return {
+        ...result,
+        pivot_detected: isPivot.isPivot || false,
+        pivot_similarity: isPivot.similarity || 1,
+        pivot_back: result.pivot?.matchedId || null,
+    };
+}
+export function predictVibeMaX(input = {}) {
+    const r = vibemaxSelectMode(input);
+    return { label: r.mode, confidence: r.confidence, source: "vibemax", source_prediction: r.source_prediction, pivot_back: r.pivot?.matchedId || null };
+}
+function extractVibeMaXFeatures(text, sr) {
+    const t = (text || "").toLowerCase();
+    const words = t.split(/\s+/).filter(Boolean);
+    const f = {
+        length: text.length / 5000,
+        word_count: words.length / 500,
+        sentence_count: (text.split(/[.!?]+/).filter(s => s.trim()).length) / 50,
+        question_ratio: (text.match(/\?/g) || []).length / Math.max(text.split(/[.!?]+/).length, 1),
+        code_blocks: (text.match(/```/g) || []).length / 10,
+        urgency: /urgent|asap|immediately|critical|broken|failing|crash|error|bug/i.test(text) ? 1.0 : 0.0,
+        complexity: /complex|difficult|hard|confusing|trick|subtle|nuance/i.test(text) ? 1.0 : 0.0,
+        instruction_density: /do not|must|should|always|never|critical/i.test(text) ? 1.0 : /please|could you|maybe|perhaps/i.test(text) ? 0.3 : 0.6,
+    };
+    return {
+        ...Object.fromEntries(Object.entries(f).filter(([_, v]) => typeof v === "number")),
+        word_count: words.length,
+        has_question: t.includes("?") ? 1 : 0,
+        has_debug: /debug|fix|broken|error|bug/.test(t) ? 1 : 0,
+        has_explain: /explain|what|how|why|compare|review/.test(t) ? 1 : 0,
+        has_refactor: /refactor|optimize|clean|improve/.test(t) ? 1 : 0,
+        has_short: words.length <= 3 ? 1 : 0,
+    };
+}
+function extractFeatureVector(text, sr) {
+    const feats = extractVibeMaXFeatures(text, sr);
+    return Object.values(feats).filter(v => typeof v === "number" && Number.isFinite(v));
+}
+export function trainVibeMaXModelFromTelemetry(telemetryPath) {
+    const raw = readFileSync(telemetryPath, "utf-8").trim();
+    const entries = raw.split("\n").filter(l => l.trim()).map(l => JSON.parse(l));
+    const fbMode = { audit: "optimized", budget: "budget", quality: "optimized", speed: "budget", longrun: "optimized" };
+    const classes = ["optimized", "budget"];
+    const samples = [];
+    for (const e of entries) {
+        const t = e.telemetry || {};
+        const text = t.input?.user_text || e.text || "";
+        const sr = t.signals?.sub_regime || t.input?.sub_regime || "INIT";
+        const mode = t.selection?.optimization_mode || t.control_vector?.optimization_mode || t.mode || "";
+        if (!text || text.length < 2)
+            continue;
+        const target = fbMode[mode] || "optimized";
+        const features = extractFeatureVector(text, sr);
+        if (features.length > 0)
+            samples.push({ features, label: target, text, sr, original_mode: mode });
+    }
+    if (samples.length < 2) {
+        const boot = [
+            // Technical / coding (16)
+            { text: "hi", sr: "INIT", label: "budget" },
+            { text: "what time is it", sr: "INIT", label: "budget" },
+            { text: "show current status", sr: "INIT", label: "budget" },
+            { text: "just give me quick answer", sr: "INIT", label: "budget" },
+            { text: "review error handling", sr: "EXPLORING", label: "optimized" },
+            { text: "this is broken fix it immediately", sr: "REFINING", label: "optimized" },
+            { text: "help me debug this failing test", sr: "REFINING", label: "optimized" },
+            { text: "we are repeating the same solution", sr: "LOOPING", label: "budget" },
+            { text: "I need complete investigation with reasoning", sr: "RESEARCH", label: "optimized" },
+            { text: "research the right documentation", sr: "RESEARCH", label: "optimized" },
+            { text: "implement new feature with comprehensive tests", sr: "REFINING", label: "optimized" },
+            { text: "lets wrap up and ship final change", sr: "CONVERGING", label: "optimized" },
+            { text: "compare Redis vs Memcached performance", sr: "EXPLORING", label: "optimized" },
+            { text: "search for all TODO comments", sr: "EXPLORING", label: "optimized" },
+            { text: "whats the next step", sr: "INIT", label: "budget" },
+            { text: "why does this keep looping", sr: "LOOPING", label: "budget" },
+            // Non-technical (20)
+            { text: "summarize this article", sr: "INIT", label: "budget" },
+            { text: "tell me a joke", sr: "INIT", label: "budget" },
+            { text: "translate hello to spanish", sr: "INIT", label: "budget" },
+            { text: "whats the weather like", sr: "INIT", label: "budget" },
+            { text: "write a quick email", sr: "INIT", label: "budget" },
+            { text: "draft a meeting agenda", sr: "INIT", label: "audit" },
+            { text: "analyze this spreadsheet data and find outliers", sr: "EXPLORING", label: "optimized" },
+            { text: "compare these two products for my purchase decision", sr: "EXPLORING", label: "optimized" },
+            { text: "review this contract for legal issues", sr: "EXPLORING", label: "optimized" },
+            { text: "help me brainstorm marketing ideas", sr: "DIVERGENT", label: "audit" },
+            { text: "edit this essay for grammar and clarity", sr: "REFINING", label: "audit" },
+            { text: "improve the structure of this presentation", sr: "REFINING", label: "optimized" },
+            { text: "proofread this resume and suggest improvements", sr: "REFINING", label: "optimized" },
+            { text: "create a budget spreadsheet for my startup", sr: "REFINING", label: "optimized" },
+            { text: "write a detailed business report on market trends", sr: "RESEARCH", label: "optimized" },
+            { text: "research competitors for my business idea", sr: "RESEARCH", label: "optimized" },
+            { text: "study this financial model and verify projections", sr: "RESEARCH", label: "optimized" },
+            { text: "generate a social media content calendar", sr: "REFINING", label: "optimized" },
+            { text: "we keep going in circles on this decision", sr: "LOOPING", label: "budget" },
+            { text: "finalize the press release", sr: "CONVERGING", label: "optimized" },
+        ];
+        for (const b of boot) {
+            const features = extractFeatureVector(b.text, b.sr);
+            if (features.length > 0)
+                samples.push({ features, label: b.label, text: b.text, sr: b.sr, original_mode: b.label });
+        }
+    }
+    const treeCount = 29, maxDepth = 5, minLeaf = 2;
+    const rngFn = rng(42);
+    const trees = [];
+    for (let i = 0; i < treeCount; i++) {
+        const bag = [];
+        for (let j = 0; j < samples.length; j++)
+            bag.push(samples[Math.floor(rngFn() * samples.length)]);
+        trees.push(buildTree(bag, classes, 0, maxDepth, minLeaf, rngFn));
+    }
+    let correct = 0;
+    for (const s of samples) {
+        const votes = {};
+        for (const t of trees) {
+            const r = predictTree(t, s.features);
+            votes[r.prediction] = (votes[r.prediction] || 0) + 1;
+        }
+        const pred = Object.entries(votes).sort((a, b) => b[1] - a[1])[0]?.[0] || classes[0];
+        if (pred === s.label)
+            correct++;
+    }
+    const model = { trees, classes, trained_at: new Date().toISOString(), samples: samples.length, metrics: { accuracy: correct / Math.max(samples.length, 1), total_samples: samples.length }, config: { think: "full", wbp: "normal", kp: [3, 6] } };
+    saveVibeMaXModel(model);
+    return model;
+}
+export function loadVibeMaXModel() {
+    if (existsSync(MODEL_PATH))
+        return JSON.parse(readFileSync(MODEL_PATH, "utf-8"));
+    return null;
+}
+export function saveVibeMaXModel(model) {
+    mkdirSync(dirname(MODEL_PATH), { recursive: true });
+    writeFileSync(MODEL_PATH, JSON.stringify(model, null, 2) + "\n", "utf-8");
+}
+export function getVibeMaXModelMeta() {
+    const m = loadVibeMaXModel();
+    if (!m)
+        return { available: false, path: MODEL_PATH, message: "not trained" };
+    return { available: true, path: MODEL_PATH, trained_at: m.trained_at, accuracy: m.metrics?.accuracy, samples: m.samples, trees: m.trees?.length, classes: m.classes };
+}