vibeostheog 0.25.53 → 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,17 @@
-# 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:
+
+1. Routing and enforcement decide which tier should act.
+2. Context compression keeps the hot path small and pushes old tool output into scratch storage.
+3. Pattern learning remembers recurring friction and routine, per project first and cross-project second.
+4. Quality signals combine reward, lie detection, and laziness detection so bad runs are visible.
 
 ## How It Feels
 
@@ -22,33 +29,25 @@ The VibeBoX decision engine watches how you work. Are you exploring a new codeba
 
 The stress detector reads your messages for signs of frustration -- repeated failures, urgency, abrupt tone. When it senses stress above a threshold, it upgrades your model tier automatically. You get the best possible assistance while you are in the weeds, and you never had to ask.
 
-The lie detector flags when the assistant claims success without evidence. The laziness detector catches short outputs, TODO placeholders, and skipped delegation on brain tier. The reward engine gamifies quality with XP credits for good outcomes and penalties for bad ones. You forget vibeOS is even running. That is the point.
+The lie detector flags when the assistant claims success without evidence. The laziness detector catches short outputs, TODO placeholders, and skipped delegation on brain tier. The reward engine rolls those signals into one quality score so the UI stays simple. You forget vibeOS is even running. That is the point.
 
 ## 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
 
-The cascade design is informed by recent work in LLM routing and cascade inference:
-
-**Dekoninck et al. (2024)** -- "A Unified Approach to Routing and Cascading for LLMs" (arXiv:2410.10347, 52 citations). Foundational framework showing cascade routing is theoretically optimal when calibrated routers can estimate input difficulty. Proves cascades Pareto-dominate single-model inference on the quality-cost curve. This is the theoretical basis for vibeOS's claim that a three-stage cascade can outperform a single expensive model on both quality and cost simultaneously.
-
-**Moslem & Kelleher (2026)** -- "Dynamic Model Routing and Cascading for Efficient LLM Inference: A Survey" (arXiv:2603.04445, 10 citations). Comprehensive survey covering all routing paradigms: classifier-based, embedding-based, RL-based, hybrid. Establishes cascade routing as a well-studied class with practical deployment strategies. Validates that the cheap-propose / mid-review / pro-polish pattern is a known and effective architecture, not an ad hoc design.
-
-**Jiang et al. (2025)** -- "Cascadia: An Efficient Cascade Serving System for Large Language Models" (arXiv:2506.04203, 3 citations). Co-optimizes deployment and routing -- reduces compute cost 42% and latency 50% vs. naive cascade serving. Demonstrates that cascades work in practice, not just in theory. The cost reduction numbers align closely with vibeOS's measured 58% cost reduction under VibeUltraX.
-
-**Bouchard (2026)** -- "Is Escalation Worth It? A Decision-Theoretic Characterization of Cascade Routing at Inference Time" (arXiv:2604.04408, 1 citation). Models escalation as a binary decision problem. Shows cascades pay off when router accuracy exceeds 84% and cheaper model failure rate is above 5%. Below that, flat routing dominates. This work informs vibeOS's escalation thresholds: the cascade only escalates when the router confidence exceeds the point where flat routing would be better.
+The cascade shape follows the general LLM routing literature, but the live source of truth is the code in this repo. The runtime does not depend on external papers; it depends on the router, the hooks, and the state files below.
 
 ### VibeBoX Decision Engine
 
@@ -69,17 +68,17 @@ A real-time stress scoring pipeline analyzes user messages for frustration signa
 
 ### Pattern Learner
 
-Per-project friction and routine tracking. The pattern learner observes which tools you use, what errors recur, and where you spend most of your time. Over time, it surfaces optimization suggestions and learns struggle/tech co-occurrence mappings. Cross-project patterns are stored in global-learning.json and inform pricing hints and routing hints.
+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.
 
-### Token Compression
+### Context Compression
 
-Three-layer compression pipeline reduces token waste without losing semantic content:
+Three small layers keep context under control without pretending to be a full memory system:
 
-1. **Web fetch stripping** (`compressText`) -- Applied immediately after webfetch tool execution. Strips verbose status lines, file-operation prefixes, and bullet markers. Collapses blank lines. If the result still exceeds 2000 characters, extracts bullet-priority lines and truncates to 30% of original size. Threshold: 2000 characters minimum.
+1. **Web fetch stripping** (`compressText`) -- Applied immediately after webfetch tool execution. It strips verbose status lines, file-operation prefixes, and bullet markers, then collapses blank lines. If the result still exceeds 2000 characters, it keeps the most useful lines and truncates the rest.
 
-2. **Cold-storage context compression** (`compressToolOutputs`) -- Runs on every LLM turn via the messages transform hook. Tool outputs older than the last 10 messages (the "hot window") are written to content-addressed cold storage (`~/.claude/scratchpad/by-hash/{hash}.txt`) and replaced with a ~200-character summary reference. Hot messages stay fully expanded so the LLM can reference recent context. Savings are estimated per-model using `cacheSavePer1MInputTokens()` and recorded to the delegation state.
+2. **Cold-storage context compression** (`compressToolOutputs`) -- Runs on every LLM turn via the messages transform hook. Tool outputs older than the last 10 messages are written to content-addressed cold storage and replaced with a short summary reference. Hot messages stay expanded so the model can still use recent context.
 
-3. **Project memory directives** (`projectMemoryDirective`) -- Compresses per-project state (sessions, reports, tech stack, topics) into a single-line directive injected into the system prompt. Full JSON stored for audit; prompt gets only the compact form.
+3. **Project memory directives** (`projectMemoryDirective`) -- Shrinks per-project state into a single-line directive for the system prompt while keeping the full JSON for audit.
 
 The remote API also exposes a `POST /api/v1/compress/context` endpoint for server-side bullet-point extraction, available as a fallback for arbitrary text compression.
 
@@ -108,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
 
@@ -158,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).
 
@@ -178,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,8 +200,8 @@ 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, SSE real-time push for model split, savings, session history, controls |
-| Trinity runtime | Switch tiers mid-session, change optimization mode, toggle subsystems live |
+| 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 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 |
@@ -210,7 +209,7 @@ Stress > 1.5 escalates any regime to quality mode regardless of the above mappin
 | Stress-aware routing | Real-time stress scoring, auto-escalation, system prompt inoculation |
 | 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 |
+| MCP server | Extended tool capabilities + dashboard serving + HTTP dashboard endpoints |
 | Remote API | Fastify server at api.vibetheog.com with token auth and seat management |
 | Session lock | `vibe lock on\|off` -- freezes model at session start |
 | Model locking | Per-session lock that skips auto-reconcile with OpenCode config changes |
@@ -223,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) |
@@ -303,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
@@ -323,7 +322,7 @@ Remote API (api.vibetheog.com) enables: bootstrap token exchange, advanced VibeB
 
 ### What Is Missing For A True Session Orchestrator
 
-The live dashboard now covers the executive Home summary, session actions, and session-scoped templates. Still missing: session versioning/undo, template versioning, batch operations, real-time WebSocket updates, session comparison, and export/import.
+The live dashboard now covers the executive Home summary, session actions, and session-scoped templates. Still missing: session versioning/undo, template versioning, batch operations, live push transport, session comparison, and export/import.
 
 ### Live Footer
 
@@ -407,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 |
@@ -419,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";