vibeostheog 0.25.54 → 0.25.55

package/CHANGELOG.md

@@ -1,3 +1,50 @@
+## 0.25.55
+- fix: persist cascade depth from backend route so footer shows cascade icon (#369)
+- fix: make the cascade real — canonical blackbox records, live audit trail, durable bridges (#366)
+- fix: stop config.update/opencode.json mid-turn writes that abort OpenCode turns (#365)
+- fix: stop mid-turn opencode.json writes that abort OpenCode turns (#357)
+- fix: stop vibeultrax from over-triggering stall recovery (#354)
+- fix: clean up legacy config stubs before turns (#353)
+- fix: unify vibe primary agent topology (#352)
+- fix: add tool-call loop circuit-breaker to stop runaway bash poll loops (#350)
+- fix: remove VIBEOS_API_DISABLED=true persistence from disk (#348)
+- fix: allow explicit setting of embedded API token (#347)
+- fix: deploy script never overwrites VIBEOS_HOME/.env.production (#346)
+- fix: api hot-path deadline + blackbox state consolidation + spec contract (#345)
+- fix: persist cascade depth/root to blackbox state across turns (#343)
+- fix: prevent stale .js shadowing and cascade de-escalation (#342)
+- fix: consolidate runtime OpenCode home resolution to single ~/.opencode (#338)
+- fix: single source of truth for the footer — kill the "always cut" fallback (#331)
+- fix: force pipeline repair when manual mode pipeline is collapsed (#330)
+- fix: force pipeline repair when manual mode pipeline is collapsed
+- fix: footer bail-out + pipeline collapse (#329)
+- refactor: split maintainability boundaries into focused modules (#358)
+- refactor: consolidate safeJsonParse to one canonical helper (#356)
+- chore: untrack internal-only MD files from repo (#351)
+fix cascade: complex prompts at any confidence route to brain tier (#368)
+Fix local loop authority (#367)
+Fix mega test loader paths and spec claims (#364)
+Narrow shell loop guard to polling (#363)
+Suppress repeated LOOPING notices (#362)
+Make LOOPING sticky across authoritative state writes (#361)
+Show cascade escalation labels (#360)
+Unify session events under VIBEOS_HOME (#359)
+Fix/api client consolidation (#355)
+Migrate test suite to TS and fix buildFooterAlert null crash (#344)
+Migrate repo to TS-only sources (#341)
+Codex/fix cascade authority (#340)
+Consolidate vibeOS skill install (#339)
+Bind vibe tiers to live OpenCode agents (#337)
+Fix VibeUltraX cheap-tier default via the OpenCode dropdown lever (#336)
+Fix VibeUltraX cascade with tier subagents (#335)
+Fix VibeUltraX live root state (#334)
+Fix VibeUltraX cascade routing (#333)
+Fix live control vector persistence (#332)
+Revert "fix: force pipeline repair when manual mode pipeline is collapsed"
+Fix blackbox session-id fragmentation freezing all sessions at INIT (#328)
+Fix footer runtime probe path (#327)
+
+
 ## 0.25.53
 - fix: add project/blackbox cards to home summary, fix template source detection, expand recommendations (#302)
 Merge release v0.25.52 into master

package/README.md

@@ -1,10 +1,10 @@
-# vibeOS for OpenCode -- Innocence v0.25.52
+# vibeOS for OpenCode -- Innocence v0.25.55
 
 A quality-first control plane for AI-assisted coding.
 
 When AI coding is cheap, you use more of it. That is the upside of the current moment -- the marginal cost of a code suggestion has collapsed. But volume does not equal quality. The more you delegate to AI, the more often a mediocre suggestion slips through: a half-implemented fix, a fabricated API call, a test that passes only because the assertions are stubs. The quality problem gets worse as the cost problem gets better. vibeOS exists to solve the quality problem. The savings are a side effect.
 
-OpenCode Desktop gives you access to the most capable language models ever created -- Opus, Sonnet, DeepSeek v4 Pro -- but running them on every single turn adds up fast. More importantly, routing every turn through the most expensive model does not guarantee the best output. A cheap model proposing, a mid-tier model reviewing, and a top-tier model polishing often produces better results than a single expensive model guessing alone. vibeOS makes that routing decision automatically, on every turn, based on what you are actually doing.
+OpenCode Desktop gives you access to the most capable language models ever created -- Opus, Sonnet, DeepSeek v4 Pro -- but running them on every single turn adds up fast. More importantly, routing every turn through the most expensive model does not guarantee the best output. vibeOS keeps one primary `vibe` agent in the dropdown, lets same-provider tier changes swap in-thread, and delegates cross-provider tier work to tier subagents without rewriting the active agent every turn.
 
 The real system is smaller than the feature list makes it sound:
 
@@ -33,17 +33,17 @@ The lie detector flags when the assistant claims success without evidence. The l
 
 ## The Cascade Engine
 
-vibeOS uses a three-tier cascade to route every turn through the cheapest model that can produce a quality result.
+vibeOS uses a single primary `vibe` agent plus three tier subagents to route every turn through the cheapest model that can produce a quality result.
 
 ### How It Works
 
-1. **Cheap proposal** -- Your configured cheap slot generates an initial response (e.g., a local Ollama model via `vibe set cheap magiccoder:7b`, or any API model).
-2. **Flash review** -- A mid-tier model (DeepSeek v4 Flash) critiques and refines the proposal.
-3. **Pro polish** -- The brain-tier model (DeepSeek v4 Pro) applies a final quality pass on complex sections.
+1. **Cheap proposal** -- The unified `vibe` primary starts on your configured cheap slot (e.g., a local Ollama model via `vibe set cheap magiccoder:7b`, or any API model).
+2. **Flash review** -- The medium tier runs as a subagent and critiques/refines the proposal without changing the dropdown agent.
+3. **Pro polish** -- The brain tier runs as a subagent on complex sections; cross-provider work delegates there instead of flipping the active agent.
 
 Not every turn goes through all three stages. The cascade router estimates input difficulty and routes simple queries directly to the cheap tier. Complex reasoning, multi-file edits, and ambiguous instructions escalate to medium or brain. The router learns from session outcomes and calibrates its thresholds over time.
 
-Benchmarked at **107% of raw brain quality at 58% of cost**. Local inference is free; only the Flash and Pro stages incur API costs. This is the first routing strategy that Pareto-dominates the raw brain baseline -- better quality, lower cost.
+Benchmarked at **107% of raw brain quality at 58% of cost**. Local inference is free; only the Flash and Pro stages incur API costs. This is the first routing strategy that Pareto-dominates the raw brain baseline -- better quality, lower cost, without per-turn agent churn.
 
 ### Research Foundation
 
@@ -68,7 +68,7 @@ A real-time stress scoring pipeline analyzes user messages for frustration signa
 
 ### Pattern Learner
 
-Per-project friction and routine tracking. The learner watches repeated tool failures, recovery loops, and stable workflows, then stores the result locally first. Cross-project hints are merged later into `global-learning.json` so the client can stay small while still learning.
+Per-project friction and routine tracking. The learner watches repeated tool failures, recovery loops, and stable workflows, then stores the result locally first. Cross-project hints are merged later into `VIBEOS_HOME/global-learning.json` so the client can stay small while still learning.
 
 ### Context Compression
 
@@ -107,7 +107,7 @@ The smart cache predicts whether a tool query will hit scratchpad cache before e
 
 The prediction engine (`predictCacheHit`) computes a confidence score and returns whether caching is worthwhile, estimated savings, and the most similar cached entries. Per-tool hit rates are tracked with exponential decay (DECAY = 0.9) so recent performance matters more than historical averages.
 
-Cache state persists across sessions in `~/.claude/global-learning.json` with a 7-day TTL eviction. The prediction results feed into the delegation enforcer's cost calculations and appear in the live footer savings display.
+Cache state persists across sessions in `VIBEOS_HOME/global-learning.json` with a 7-day TTL eviction. The prediction results feed into the delegation enforcer's cost calculations and appear in the live footer savings display.
 
 ### Pivot and Counter-Pivot
 
@@ -157,13 +157,13 @@ DeepSeek Chat costs $0/turn when routed through the Direct DeepSeek provider (no
 
 | Policy | Quality vs Brain | Cost vs Brain | Savings | Method |
 |--------|-----------------|--------------|---------|--------|
-| VibeUltraX | 107% | 0.58x | 42% | cheap -> medium -> brain cascade |
+| VibeUltraX | 107% | 0.58x | 42% | vibe primary + tier subagents |
 | VibeQMaX | ~100% | 0.50x | 50% | same model, framework optimizations |
 | Raw Brain | 100% | 1.00x | - | baseline |
 | VibeMaX | ~75% | 0.18x | 82% | trained cascade (conservative escalate) |
 | Budget | ~40% | 0.00x | 100% | direct routing |
 
-**VibeUltraX** -- Default mode. Cheap slot proposes, medium reviews, brain refines. 107% quality at 58% cost.
+**VibeUltraX** -- Default mode. The unified `vibe` primary starts on cheap, medium and brain run as subagents, and same-provider escalations stay in-thread. 107% quality at 58% cost.
 
 **VibeQMaX** -- Routes strategic turns through v4 Pro with full thinking, strict enforcement, strict flow checks, and quality TDD. Write/edit delegated per enforcement rules. Blended cost ~$0.00029/turn (50% of brain baseline).
 
@@ -177,7 +177,7 @@ DeepSeek Chat costs $0/turn when routed through the Direct DeepSeek provider (no
 |------|-------|----------|-------------|------|-----|
 | Raw Brain | v4 Pro | full | - | - | - |
 | VibeQMaX | v4 Pro | full | strict | strict | quality |
-| VibeUltraX | cascade (cheap->medium->brain) | auto | auto | auto | auto |
+| VibeUltraX | vibe primary + tier subagents | auto | auto | auto | auto |
 | VibeMaX | v4 Flash (auto-escalate) | auto | auto | auto | auto |
 | Speed | v4 Flash | off | relaxed | audit | lazy |
 | Budget | DeepSeek Chat | off | relaxed | audit | lazy |
@@ -201,7 +201,7 @@ Stress > 1.5 escalates any regime to quality mode regardless of the above mappin
 | Delegation enforcement | Blocks write/edit on brain tier, routes to cheaper tiers transparently |
 | Live savings footer | Tier, provider, model name, total savings, mode -- one line of reassurance |
 | Web dashboard | Session-first SolidJS SPA with executive Home summary, session actions, per-session templates, polling refresh for model split, savings, session history, controls |
-| Trinity runtime | Update tier slots through the native OpenCode config path, change optimization mode, toggle subsystems live |
+| Trinity runtime | Update tier slots and keep the unified vibe primary plus tier subagents synced through the native OpenCode config path, change optimization mode, toggle subsystems live |
 | Flow enforcer | Pattern-rule checks on write/edit. Extracts TODO/FIXME into append-only queue. |
 | TDD enforcer | Auto-creates test skeletons for changed source. Strict mode fails TODO tests. |
 | Pattern learner | Tracks recurring struggle/routine patterns per project, cross-project too |
@@ -222,7 +222,7 @@ Stress > 1.5 escalates any regime to quality mode regardless of the above mappin
 | Claim verification | Scans assistant output for made-up references, validates against codebase |
 | Token compression | Web fetch output stripped to 30% of original size -- verbose lines, bullet prefixes, and blank lines collapsed. Tool output history compressed to cold-storage references after the hot window (last 10 messages). Project memory condensed to single-line directives for system prompts. |
 | Rotation memory | Scratchpad files age through a four-stage lifecycle: fresh (< 5 min, full content), warm (5 min - 24 hr, 500-char summary), cold (24 - 48 hr, 200-char summary), expired (> 48 hr, deleted). Rotation runs opportunistically on every tool execution, throttled to once per minute. Cache hits degrade gracefully over time instead of failing abruptly. |
-| Smart cache | Predicts whether a tool query will hit scratchpad cache using composite similarity scoring (Jaccard + cosine bigram + weighted keyword overlap). Per-tool hit rates tracked with exponential decay. Estimated savings calculated and displayed in the live footer. Cache entries persisted across sessions via global-learning.json with 7-day TTL eviction. |
+| Smart cache | Predicts whether a tool query will hit scratchpad cache using composite similarity scoring (Jaccard + cosine bigram + weighted keyword overlap). Per-tool hit rates tracked with exponential decay. Estimated savings calculated and displayed in the live footer. Cache entries persisted across sessions via `VIBEOS_HOME/global-learning.json` with 7-day TTL eviction. |
 | Pivot / counter-pivot | Detects when you switch topics mid-session (forward pivot) and when you return to a previously abandoned workflow (counter-pivot). Forward pivots snapshot the old workflow context and downgrade to budget mode. Counter-pivots restore files, decisions, blockers, and code snippets from cached workflow snapshots into the system prompt. |
 | Deferred reports | saveReport deferred to setTimeout to avoid blocking tool output |
 | Stress gauge footer | Live indicator in footer -- ▁▂▃▅▆█ (none/minimal/calm/elevated/high/critical) |
@@ -302,9 +302,9 @@ vibeOS hooks into OpenCode Desktop through 8 extension points:
 | experimental.session.compacting | Preserves savings state |
 | shell.env | Injects OPENCODE_MODEL_TIER and OPENCODE_MODEL |
 
-### State Files (~/.claude/)
+### State Files (`VIBEOS_HOME/`)
 
-The plugin persists state to ~/.claude/ for cross-session continuity:
+The plugin persists state to `VIBEOS_HOME/` for cross-session continuity:
 
 - **delegation-state.json** -- Sessions, warns, cache hits, lifetime totals
 - **model-tiers.json** -- Brain/medium/cheap model IDs
@@ -406,6 +406,19 @@ The footer is the primary status line, appended to every assistant response. It
 | ⟡ medium | Active slot changed to medium this turn |
 | ⟡ brain | Active slot changed to brain this turn |
 
+#### Alert Tags
+
+The alert is part of the one footer (it is **not** a separate line). When present it renders
+after the enforcement tags and before the stress gauge. Multiple alerts join with ` · `.
+This table is the single source of truth — `buildFooterAlert()` must match it exactly.
+
+| Alert | Trigger |
+|-------|---------|
+| ⚠ api degraded | API latency is degraded / the backend is unhealthy this turn |
+| ⚠ switch pending | A tier switch is deferred and will apply at the next turn boundary |
+| ⚠ model drift | The live model is outside the cascade tiers and differs from the expected slot model |
+| ⚠ model unreachable | The last model call failed with a network error (EHOSTUNREACH / ENOTFOUND / ETIMEDOUT) |
+
 **Segments (left to right):**
 
 | Segment | Format | Example | Meaning |
@@ -418,6 +431,7 @@ The footer is the primary status line, appended to every assistant response. It
 | Brand + mode label | VibeBrand . modeLabel | VibeUltraX . Quality | Requested mode + regime-derived label |
 | Cascade icon | >>> or >> | >>> | VibeUltraX cascade depth >= 3 |
 | Enforcement tags | guarded, flow steady, tests live | guarded | Guard state summary |
+| Alert tags | ⚠ alert · ⚠ alert | ⚠ model drift | Live status alerts (see Alert Tags) |
 | Stress gauge | gaugeChar | _ | Current stress level |
 | Vector pulse | slot | cheap | Active slot changed this turn |
 

package/bin/setup.js

@@ -1,47 +1,153 @@
 #!/usr/bin/env node
 
+// src/bin/setup.ts
 import { execSync } from "node:child_process";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "node:fs";
+import { dirname as dirname2, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveOpenCodeHome, resolveOpenCodeHomes } from "../scripts/lib/opencode-homes.mjs";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const root = resolve(__dirname, "..");
-const args = process.argv.slice(2);
-const command = args.find(a => !a.startsWith("-")) ?? "setup";
-const isInstallCommand = command === "setup" || command === "set";
-const isProject = args.includes("--project");
-const isYes = args.includes("--yes") || args.includes("-y");
+// scripts/lib/opencode-homes.mjs
+import { join } from "node:path";
+import { homedir } from "node:os";
+function resolveOpenCodeHomes({ home = homedir() } = {}) {
+  const override = process.env.VIBEOS_OPENCODE_HOME;
+  if (override) return [override];
+  return [join(home, ".opencode")];
+}
+function resolveOpenCodeHome(opts = {}) {
+  return resolveOpenCodeHomes(opts)[0];
+}
 
+// scripts/lib/vibe-tier-agents.mjs
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var VIBE_TIER_AGENT_BY_SLOT = {
+  cheap: "vibe-cheap",
+  medium: "vibe-medium",
+  brain: "vibe-brain"
+};
+var VIBE_PRIMARY_AGENT = "vibe";
+function readJson(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const raw = readFileSync(path, "utf8");
+    const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(cleaned);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readTiers(home = homedir2()) {
+  return readJson(join2(process.env.VIBEOS_HOME || join2(home, ".claude"), "model-tiers.json"));
+}
+function primaryAgent(model, existing = {}) {
+  return {
+    ...existing && typeof existing === "object" ? existing : {},
+    description: "VibeUltraX primary agent",
+    mode: "primary",
+    model,
+    permission: {
+      read: "allow",
+      edit: "allow",
+      glob: "allow",
+      grep: "allow",
+      list: "allow",
+      bash: "allow",
+      task: "allow",
+      webfetch: "allow",
+      websearch: "allow",
+      ...existing?.permission && typeof existing.permission === "object" ? existing.permission : {}
+    }
+  };
+}
+function tierAgent(slot, model, existing = {}) {
+  return {
+    ...existing && typeof existing === "object" ? existing : {},
+    description: `VibeUltraX ${slot} tier subagent`,
+    mode: "subagent",
+    model,
+    permission: {
+      read: "allow",
+      edit: "allow",
+      glob: "allow",
+      grep: "allow",
+      list: "allow",
+      bash: "allow",
+      task: "allow",
+      webfetch: "allow",
+      websearch: "allow",
+      ...existing?.permission && typeof existing.permission === "object" ? existing.permission : {}
+    }
+  };
+}
+function installVibeTierAgentsInConfig(config, tiers = readTiers()) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) return false;
+  const trinity = tiers?.trinity || {};
+  config.$schema ||= "https://opencode.ai/config.json";
+  config.agent = config.agent && typeof config.agent === "object" ? config.agent : {};
+  let changed = false;
+  const primaryModel = String(trinity?.cheap?.oc || "").trim();
+  if (primaryModel) {
+    const existing = config.agent[VIBE_PRIMARY_AGENT];
+    const next = primaryAgent(primaryModel, existing);
+    if (JSON.stringify(existing || null) !== JSON.stringify(next)) {
+      config.agent[VIBE_PRIMARY_AGENT] = next;
+      changed = true;
+    }
+    if (config.default_agent !== VIBE_PRIMARY_AGENT) {
+      config.default_agent = VIBE_PRIMARY_AGENT;
+      changed = true;
+    }
+  }
+  for (const slot of ["cheap", "medium", "brain"]) {
+    const model = String(trinity?.[slot]?.oc || "").trim();
+    const name = VIBE_TIER_AGENT_BY_SLOT[slot];
+    if (!model || !name) continue;
+    const existing = config.agent[name];
+    const next = tierAgent(slot, model, existing);
+    if (JSON.stringify(existing || null) !== JSON.stringify(next)) {
+      config.agent[name] = next;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+// src/bin/setup.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var root = resolve(__dirname, "..");
+var args = process.argv.slice(2);
+var command = args.find((a) => !a.startsWith("-")) ?? "setup";
+var isInstallCommand = command === "setup" || command === "set";
+var isProject = args.includes("--project");
+var writeLine = (text = "") => {
+  process.stdout.write(text + "\n");
+};
 if (!isInstallCommand || args.includes("--help") || args.includes("-h")) {
   console.error("Usage: npx vibeostheog set [--project]");
   console.error("       npx vibeostheog setup [--project]");
   process.exit(1);
 }
-
-console.log("");
-console.log("vibeOS — cost-aware delegation enforcer for OpenCode");
-console.log("");
-console.log("Installing to:");
-for (const h of resolveOpenCodeHomes({ cwd: process.cwd() })) console.log("  " + h);
-console.log("");
-
-// Deploy plugin files to ~/.config/opencode/plugins/ and register globally
-const deployScript = resolve(root, "scripts", "deploy.mjs");
-if (!existsSync(deployScript)) {
+writeLine();
+writeLine("vibeOS \u2014 cost-aware delegation enforcer for OpenCode");
+writeLine();
+writeLine("Installing to:");
+for (const h of resolveOpenCodeHomes({ cwd: process.cwd() })) writeLine("  " + h);
+writeLine();
+var deployScript = resolve(root, "scripts", "deploy.mjs");
+if (!existsSync2(deployScript)) {
   console.error("Fatal: scripts/deploy.mjs not found at", deployScript);
   process.exit(1);
 }
 execSync(`node "${deployScript}"`, { stdio: "inherit", cwd: process.cwd() });
-
-// For per-project setup, also register in project-level opencode.json
 if (isProject) {
   const configPath = resolve(process.cwd(), "opencode.json");
   let config = {};
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     try {
-      config = JSON.parse(readFileSync(configPath, "utf8"));
+      config = JSON.parse(readFileSync2(configPath, "utf8"));
     } catch {
       config = {};
     }
@@ -52,13 +158,13 @@ if (isProject) {
   const installHome = resolveOpenCodeHome({ cwd: process.cwd() });
   const pluginRef = resolve(installHome, "plugins", "vibeOS.js");
   config.plugin = config.plugin.filter((p) => !(typeof p === "string" && p.includes("vibeOS")));
-  if (!config.plugin.includes(pluginRef)) {
-    config.plugin.push(pluginRef);
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  }
-  console.log(`vibeOS registered in ${configPath}`);
+  installVibeTierAgentsInConfig(config);
+  if (!config.plugin.includes(pluginRef)) config.plugin.push(pluginRef);
+  mkdirSync2(dirname2(configPath), { recursive: true });
+  const tmp = `${configPath}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync2(tmp, JSON.stringify(config, null, 2) + "\n");
+  renameSync2(tmp, configPath);
+  writeLine(`vibeOS registered in ${configPath}`);
 }
-
-console.log("");
-console.log("Done. Restart OpenCode to activate the plugin.");
+writeLine();
+writeLine("Done. Restart OpenCode to activate the plugin.");

package/dist/assets/dashboard/vibeos-dashboard-config.js

@@ -1 +1 @@
-window.__VIBEOS_DASHBOARD_BASE__ = "http://127.0.0.1:63452";
+window.__VIBEOS_DASHBOARD_BASE__ = "http://127.0.0.1:53088";