codymaster 7.0.2 → 7.0.3

package/dist/judge.js

@@ -16,11 +16,10 @@ const SKILL_DOMAIN = {
     'cm-tdd': 'engineering',
     'cm-debugging': 'engineering',
     'cm-quality-gate': 'engineering',
-    'cm-test-gate': 'engineering',
     'cm-code-review': 'engineering',
     'cm-safe-deploy': 'operations',
     'cm-identity-guard': 'operations',
-    'cm-git-worktrees': 'operations',
+    'cm-codeintell': 'operations',
     'cm-terminal': 'operations',
     'cm-planning': 'product',
     'cm-ux-master': 'product',
@@ -28,30 +27,32 @@ const SKILL_DOMAIN = {
     'cm-project-bootstrap': 'product',
     'cm-content-factory': 'growth',
     'cm-ads-tracker': 'growth',
-    'cro-methodology': 'growth',
-    'booking-calendar': 'growth',
+    'cm-cro-methodology': 'growth',
+    'cm-booking-calendar': 'growth',
     'cm-execution': 'orchestration',
     'cm-continuity': 'orchestration',
-    'cm-skill-mastery': 'orchestration',
+    'cm-skill-index': 'orchestration',
     'cm-safe-i18n': 'orchestration',
 };
 // ─── Agent Affinity ─────────────────────────────────────────────────────────
 const AGENT_AFFINITY = {
-    engineering: ['claude-code', 'cursor', 'antigravity'],
-    operations: ['claude-code', 'antigravity', 'cursor'],
-    product: ['antigravity', 'claude-code', 'cursor'],
-    growth: ['antigravity', 'claude-code', 'cursor'],
-    orchestration: ['antigravity', 'claude-code', 'cursor'],
-    specialized: ['antigravity', 'claude-code', 'cursor'],
-    debugging: ['claude-code', 'cursor', 'antigravity'],
-    review: ['antigravity', 'claude-code'],
-    documentation: ['antigravity', 'claude-code'],
-    design: ['cursor', 'antigravity'],
+    engineering: ['claude-code', 'codex', 'opencode', 'cursor', 'antigravity'],
+    operations: ['claude-code', 'codex', 'opencode', 'antigravity', 'cursor'],
+    product: ['antigravity', 'claude-code', 'cursor', 'gemini-cli'],
+    growth: ['antigravity', 'gemini-cli', 'claude-code', 'cursor'],
+    orchestration: ['antigravity', 'claude-code', 'cursor', 'gemini-cli'],
+    specialized: ['antigravity', 'claude-code', 'codex', 'opencode', 'cursor'],
+    debugging: ['claude-code', 'codex', 'opencode', 'cursor', 'antigravity'],
+    review: ['antigravity', 'claude-code', 'codex', 'opencode'],
+    documentation: ['antigravity', 'claude-code', 'gemini-cli'],
+    design: ['cursor', 'antigravity', 'gemini-cli'],
 };
 // ─── Agent Display ──────────────────────────────────────────────────────────
 const AGENT_DISPLAY = {
     'antigravity': 'Google Antigravity',
     'claude-code': 'Claude Code',
+    'codex': 'OpenAI Codex',
+    'opencode': 'OpenCode',
     'cursor': 'Cursor',
     'gemini-cli': 'Gemini CLI',
     'windsurf': 'Windsurf',

package/dist/mcp-context-server.js

@@ -562,11 +562,19 @@ const TOOLS = [
         },
     },
 ];
-// ─── MCP stdio protocol (JSON-RPC 2.0, Content-Length framing) ───────────────
+// ─── MCP stdio protocol (JSON-RPC 2.0, auto-detect framing) ─────────────────
+// Supports both NDJSON (MCP spec) and Content-Length framing (LSP-style).
+// Auto-detects based on the first message received from the client.
+let useContentLengthFraming = false;
 function sendMessage(msg) {
     const json = JSON.stringify(msg);
-    const header = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n`;
-    process.stdout.write(header + json);
+    if (useContentLengthFraming) {
+        const header = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n`;
+        process.stdout.write(header + json);
+    }
+    else {
+        process.stdout.write(json + '\n');
+    }
 }
 function respond(id, result) {
     sendMessage({ jsonrpc: '2.0', id, result });
@@ -576,10 +584,11 @@ function respondError(id, code, message) {
 }
 function handleRequest(msg) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const { id, method, params } = msg;
         if (method === 'initialize') {
             respond(id, {
-                protocolVersion: '2024-11-05',
+                protocolVersion: (_a = params === null || params === void 0 ? void 0 : params.protocolVersion) !== null && _a !== void 0 ? _a : '2024-11-05',
                 capabilities: { tools: {} },
                 serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
             });
@@ -651,31 +660,44 @@ function handleRequest(msg) {
         }
     });
 }
-// ─── Stdin reader (Content-Length framed) ────────────────────────────────────
-let buffer = Buffer.alloc(0);
+// ─── Stdin reader (supports both NDJSON and Content-Length framing) ─────────
+let stdinBuffer = '';
+process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => __awaiter(void 0, void 0, void 0, function* () {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (true) {
-        const sep = buffer.indexOf('\r\n\r\n');
-        if (sep === -1)
-            break;
-        const header = buffer.slice(0, sep).toString();
-        const match = header.match(/Content-Length:\s*(\d+)/i);
-        if (!match) {
-            buffer = buffer.slice(sep + 4);
-            break;
+    stdinBuffer += chunk;
+    while (stdinBuffer.length > 0) {
+        // Check for Content-Length framing (LSP-style)
+        const clMatch = stdinBuffer.match(/^Content-Length:\s*(\d+)\r\n\r\n/i);
+        if (clMatch) {
+            useContentLengthFraming = true;
+            const contentLength = parseInt(clMatch[1], 10);
+            const headerEnd = clMatch[0].length;
+            if (stdinBuffer.length < headerEnd + contentLength)
+                break; // wait for more data
+            const body = stdinBuffer.slice(headerEnd, headerEnd + contentLength);
+            stdinBuffer = stdinBuffer.slice(headerEnd + contentLength);
+            try {
+                const msg = JSON.parse(body);
+                yield handleRequest(msg);
+            }
+            catch (_a) {
+                // ignore malformed messages
+            }
+            continue;
         }
-        const contentLength = parseInt(match[1], 10);
-        const bodyStart = sep + 4;
-        if (buffer.length < bodyStart + contentLength)
+        // NDJSON: newline-delimited JSON
+        const nl = stdinBuffer.indexOf('\n');
+        if (nl === -1)
             break;
-        const body = buffer.slice(bodyStart, bodyStart + contentLength).toString('utf8');
-        buffer = buffer.slice(bodyStart + contentLength);
+        const line = stdinBuffer.slice(0, nl).trim();
+        stdinBuffer = stdinBuffer.slice(nl + 1);
+        if (!line)
+            continue;
         try {
-            const msg = JSON.parse(body);
+            const msg = JSON.parse(line);
             yield handleRequest(msg);
         }
-        catch (_a) {
+        catch (_b) {
             // ignore malformed messages
         }
     }

package/dist/mcp-skills-tools.js

@@ -49,8 +49,8 @@ function cmReviewTool(projectPath) {
 function cmQaTool(projectPath) {
     return {
         browse_daemon: 'Run: cm browse start --token <secret> then POST /session/start',
-        visual: 'cm qa-visual --url http://localhost:3000',
-        gates: ['cm-quality-gate', 'cm-test-gate'],
+        visual: 'Use the cm-browse workflow against http://localhost:3000 for visual QA',
+        gates: ['cm-quality-gate'],
     };
 }
 function cmDeployTool(projectPath) {

package/dist/skill-chain.js

@@ -21,6 +21,7 @@ const builtin_1 = require("./chains/builtin");
 const context_bus_1 = require("./context-bus");
 const execution_analyzer_1 = require("./execution-analyzer");
 const storage_backend_1 = require("./storage-backend");
+const skill_execution_cache_1 = require("./skill-execution-cache");
 // ─── Chain Matching ─────────────────────────────────────────────────────────
 // TRIZ #10: Preliminary Action — analyze task BEFORE dispatching
 /**
@@ -114,15 +115,36 @@ function findChain(chainId) {
 function createChainExecution(chain, projectId, taskTitle, agent, projectPath) {
     const now = new Date().toISOString();
     const backend = projectPath ? (0, storage_backend_1.getBackend)(projectPath) : undefined;
+    const cache = projectPath ? new skill_execution_cache_1.SkillExecutionCache(projectPath) : undefined;
     let selectedSteps;
+    let cacheHit = false;
     backend === null || backend === void 0 ? void 0 : backend.initialize();
+    cache === null || cache === void 0 ? void 0 : cache.initialize();
     try {
-        selectedSteps = selectTopSkills(taskTitle, chain, 3, {
-            getSkillMetric: backend ? (skill) => backend.getSkillMetric(skill) : undefined,
-        });
+        const cachedChain = cache === null || cache === void 0 ? void 0 : cache.findCachedChain(taskTitle);
+        if (cachedChain === null || cachedChain === void 0 ? void 0 : cachedChain.skillChain.length) {
+            const selectedSkills = new Set(cachedChain.skillChain);
+            const cachedSteps = chain.steps.filter(step => selectedSkills.has(step.skill));
+            if (cachedSteps.length > 0) {
+                selectedSteps = cachedSteps;
+                cache === null || cache === void 0 ? void 0 : cache.recordHit(cachedChain.taskPattern);
+                cacheHit = true;
+            }
+            else {
+                selectedSteps = selectTopSkills(taskTitle, chain, 3, {
+                    getSkillMetric: backend ? (skill) => backend.getSkillMetric(skill) : undefined,
+                });
+            }
+        }
+        else {
+            selectedSteps = selectTopSkills(taskTitle, chain, 3, {
+                getSkillMetric: backend ? (skill) => backend.getSkillMetric(skill) : undefined,
+            });
+        }
     }
     finally {
         backend === null || backend === void 0 ? void 0 : backend.close();
+        cache === null || cache === void 0 ? void 0 : cache.close();
     }
     const steps = selectedSteps.map((step, index) => ({
         index,
@@ -149,6 +171,7 @@ function createChainExecution(chain, projectId, taskTitle, agent, projectPath) {
         steps,
         startedAt: now,
         updatedAt: now,
+        cacheHit,
     };
     // Init context bus for this chain execution
     if (projectPath) {

package/dist/skill-token-report.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSkillTokenFootprint = analyzeSkillTokenFootprint;
+exports.formatSkillTokenReport = formatSkillTokenReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const token_budget_1 = require("./token-budget");
+function fileStat(filePath) {
+    const content = fs_1.default.readFileSync(filePath, 'utf-8');
+    return {
+        path: filePath,
+        bytes: Buffer.byteLength(content, 'utf-8'),
+        lines: content === '' ? 0 : content.split('\n').length,
+        tokens: (0, token_budget_1.estimateTokens)(content),
+    };
+}
+function addStats(pathLabel, stats) {
+    return stats.reduce((acc, stat) => ({
+        path: pathLabel,
+        bytes: acc.bytes + stat.bytes,
+        lines: acc.lines + stat.lines,
+        tokens: acc.tokens + stat.tokens,
+    }), { path: pathLabel, bytes: 0, lines: 0, tokens: 0 });
+}
+function delta(from, to) {
+    return {
+        bytes: from.bytes - to.bytes,
+        lines: from.lines - to.lines,
+        tokens: from.tokens - to.tokens,
+    };
+}
+function analyzeSkillTokenFootprint(skillName, opts = {}) {
+    var _a;
+    const projectPath = path_1.default.resolve((_a = opts.projectPath) !== null && _a !== void 0 ? _a : process.cwd());
+    const skillPath = path_1.default.join(projectPath, 'skills', skillName);
+    const skillMdPath = path_1.default.join(skillPath, 'SKILL.md');
+    if (!fs_1.default.existsSync(skillMdPath)) {
+        throw new Error(`Skill "${skillName}" not found at ${skillMdPath}`);
+    }
+    const core = fileStat(skillMdPath);
+    const referencesDir = path_1.default.join(skillPath, 'references');
+    const references = fs_1.default.existsSync(referencesDir)
+        ? fs_1.default.readdirSync(referencesDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => path_1.default.join(referencesDir, entry.name))
+            .sort((a, b) => a.localeCompare(b))
+            .map(fileStat)
+        : [];
+    const progressiveMin = Object.assign(Object.assign({}, core), { path: 'progressive_min' });
+    const progressiveMax = addStats('progressive_max', [core, ...references]);
+    const report = {
+        skill: skillName,
+        project_path: projectPath,
+        skill_path: skillPath,
+        core,
+        references,
+        progressive_min: progressiveMin,
+        progressive_max: progressiveMax,
+    };
+    if (opts.baselinePath) {
+        const baselinePath = path_1.default.resolve(projectPath, opts.baselinePath);
+        if (!fs_1.default.existsSync(baselinePath)) {
+            throw new Error(`Baseline file not found: ${baselinePath}`);
+        }
+        const baseline = fileStat(baselinePath);
+        report.baseline = {
+            path: baseline.path,
+            bytes: baseline.bytes,
+            lines: baseline.lines,
+            tokens: baseline.tokens,
+            delta_vs_progressive_min: delta(baseline, progressiveMin),
+            delta_vs_progressive_max: delta(baseline, progressiveMax),
+        };
+    }
+    return report;
+}
+function formatSkillTokenReport(report) {
+    const lines = [
+        `Skill Token Report: ${report.skill}`,
+        `Project: ${report.project_path}`,
+        `Skill path: ${report.skill_path}`,
+        '',
+        `core: ${report.core.tokens} tok · ${report.core.lines} lines · ${report.core.bytes} bytes`,
+        `progressive_min: ${report.progressive_min.tokens} tok · ${report.progressive_min.lines} lines · ${report.progressive_min.bytes} bytes`,
+        `progressive_max: ${report.progressive_max.tokens} tok · ${report.progressive_max.lines} lines · ${report.progressive_max.bytes} bytes`,
+        `references: ${report.references.length}`,
+    ];
+    if (report.references.length > 0) {
+        lines.push('');
+        lines.push('Reference files:');
+        for (const ref of report.references) {
+            lines.push(`- ${path_1.default.basename(ref.path)}: ${ref.tokens} tok · ${ref.lines} lines · ${ref.bytes} bytes`);
+        }
+    }
+    if (report.baseline) {
+        lines.push('');
+        lines.push(`baseline: ${report.baseline.tokens} tok · ${report.baseline.lines} lines · ${report.baseline.bytes} bytes`);
+        lines.push(`baseline delta vs progressive_min: ${report.baseline.delta_vs_progressive_min.tokens} tok · ${report.baseline.delta_vs_progressive_min.lines} lines · ${report.baseline.delta_vs_progressive_min.bytes} bytes`);
+        lines.push(`baseline delta vs progressive_max: ${report.baseline.delta_vs_progressive_max.tokens} tok · ${report.baseline.delta_vs_progressive_max.lines} lines · ${report.baseline.delta_vs_progressive_max.bytes} bytes`);
+    }
+    return lines.join('\n');
+}

package/dist/sprint-pipeline.js

@@ -240,12 +240,12 @@ function skillMappingForStep(step) {
     const map = {
         brainstorm: 'cm-brainstorm-idea',
         plan: 'cm-planning',
-        design: 'cm-ui-preview / cm-design-system',
+        design: 'cm-design-system',
         tdd: 'cm-tdd',
         build: 'cm-execution',
         review: 'cm-code-review',
-        qa: 'cm-quality-gate / cm-test-gate',
-        security: 'cm-secret-shield / cm-security-gate',
+        qa: 'cm-quality-gate',
+        security: 'cm-safe-deploy / cm-identity-guard',
         ship: 'cm-safe-deploy',
         monitor: 'cm-canary (post-deploy)',
         retro: 'cm-retro',

package/dist/ui/onboarding.js

@@ -280,13 +280,12 @@ function runOnboarding(version) {
                     ] },
                 { domain: '🚀 Operations', skills: [
                         { name: 'cm-safe-deploy', desc: 'Multi-gate deploy' },
-                        { name: 'cm-secret-shield', desc: 'Secret scanning' },
-                        { name: 'cm-git-worktrees', desc: 'Isolated branches' },
+                        { name: 'cm-execution', desc: 'Parallel execution + isolation' },
                         { name: 'cm-identity-guard', desc: 'Account & project safety' },
                     ] },
                 { domain: '🎨 Product & Design', skills: [
                         { name: 'cm-planning', desc: 'Plan before you code' },
-                        { name: 'cm-ui-preview', desc: 'AI-powered UI design' },
+                        { name: 'cm-design-system', desc: 'AI-powered design generation' },
                         { name: 'cm-ux-master', desc: '48 UX Laws + design system' },
                         { name: 'cm-design-system', desc: 'Design token intelligence' },
                     ] },
@@ -300,7 +299,7 @@ function runOnboarding(version) {
                         { name: 'cm-execution', desc: 'Parallel agent dispatch' },
                         { name: 'cm-skill-chain', desc: 'Multi-skill pipelines' },
                         { name: 'cm-continuity', desc: 'Working memory protocol' },
-                        { name: 'cm-skill-mastery', desc: 'Meta-skill kit discipline' },
+                        { name: 'cm-skill-index', desc: 'Meta-skill discovery discipline' },
                     ] },
                 { domain: '🔧 Workflow', skills: [
                         { name: 'cm-start', desc: 'Idea → production code' },

package/dist/utils/design-taste.js

@@ -6,7 +6,7 @@
  *
  * Storage: `.cm/design-taste.json` (JSON, not JSONL — small file, full rewrite).
  *
- * Consumed by cm-design-system and cm-ui-preview to bias token / prompt
+ * Consumed by cm-design-system to bias token / prompt
  * generation toward what the user has already approved.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {

package/dist/utils/output-compress.js

@@ -11,6 +11,7 @@ exports.compressNpmTest = compressNpmTest;
 exports.collapseRepeatedLines = collapseRepeatedLines;
 exports.summarizeBuildLog = summarizeBuildLog;
 exports.compressFor = compressFor;
+exports.compressMaybe = compressMaybe;
 const STATUS_LINE = /^(?:\s*)([MADRCU?!]{1,2}|\?\?)\s+(.+)$/;
 function compressGitStatus(stdout) {
     const lines = stdout.split('\n');
@@ -141,3 +142,10 @@ function compressFor(command, stdout) {
     }
     return collapseRepeatedLines(stdout, 3);
 }
+function compressMaybe(command, stdout, maxLines = 50) {
+    const lines = stdout.split('\n');
+    if (lines.length <= maxLines && stdout.length <= 4000) {
+        return stdout;
+    }
+    return compressFor(command, stdout);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codymaster",
-  "version": "7.0.2",
+  "version": "7.0.3",
   "description": "CodyMaster v7.0 — 50+ AI agent skills with Browse Hybrid Bridge (agent-browser + Playwright), a11y snapshots, structured error collection, video recording. Hybrid browser automation for visual QA and testing.",
   "main": "dist/index.js",
   "repository": {
@@ -37,6 +37,7 @@
     "check:platforms": "node scripts/build-skills.mjs --platforms cursor,codex,opencode --check",
     "sync:all": "node scripts/build-skills.mjs --all-platforms",
     "sync:all:check": "node scripts/build-skills.mjs --all-platforms --check",
+    "pack:plugin": "node scripts/pack-plugin.mjs",
     "changelog": "bash scripts/update-changelog.sh",
     "changelog:dry": "bash scripts/update-changelog.sh --dry-run",
     "update": "cm update --full",

package/public/dashboard/app.js

@@ -1,4 +1,4 @@
-/* CodyMaster Mission Control v4 — Multi-Project, History, Deploy, Changelog, Auto-Sync */
+/* opencode Mission Control v4 — Multi-Project, History, Deploy, Changelog, Auto-Sync */
 
 (function () {
   'use strict';
@@ -34,14 +34,14 @@
   });
   const API = '/api';
   const AGENT_COLORS = {
-    'antigravity': '#3fb950', 'claude-code': '#bc8cff', 'cursor': '#58a6ff',
-    'gemini-cli': '#d29922', 'windsurf': '#f97316', 'cline': '#a1887f',
-    'copilot': '#8b949e', 'manual': '#e6edf3',
+    'antigravity': '#3fb950', 'claude-code': '#bc8cff', 'codex': '#10a37f',
+    'cursor': '#58a6ff', 'gemini-cli': '#d29922', 'opencode': '#ff6b6b', 'windsurf': '#f97316',
+    'cline': '#a1887f', 'copilot': '#8b949e', 'manual': '#e6edf3',
   };
   const AGENT_LABELS = {
-    'antigravity': 'Antigravity', 'claude-code': 'Claude Code', 'cursor': 'Cursor',
-    'gemini-cli': 'Gemini CLI', 'windsurf': 'Windsurf', 'cline': 'Cline',
-    'copilot': 'Copilot', 'manual': 'Manual',
+    'antigravity': 'Antigravity', 'claude-code': 'Claude Code', 'codex': 'Codex',
+    'cursor': 'Cursor', 'gemini-cli': 'Gemini CLI', 'opencode': 'OpenCode', 'windsurf': 'Windsurf',
+    'cline': 'Cline', 'copilot': 'Copilot', 'manual': 'Manual',
   };
   const ACTIVITY_ICONS = {
     'task_created': '✨', 'task_moved': '↔️', 'task_done': '✅', 'task_deleted': '🗑️', 'task_updated': '✏️',
@@ -314,12 +314,11 @@
     });
 
     // Agents
-    const allAgents = {};
-    tasks.forEach(t => { if (t.agent) allAgents[t.agent] = (allAgents[t.agent] || 0) + 1; });
-    if (Object.keys(allAgents).length === 0) {
+    const visibleAgents = getVisibleAgents();
+    if (visibleAgents.length === 0) {
       agentListEl.innerHTML = '<div class="agent-empty">No active agents</div>';
     } else {
-      agentListEl.innerHTML = Object.entries(allAgents).sort((a, b) => b[1] - a[1]).map(([agent, count]) => {
+      agentListEl.innerHTML = visibleAgents.map(({ agent, count }) => {
         const color = AGENT_COLORS[agent] || '#8b949e';
         return `<div class="agent-badge"><span class="agent-dot" style="background:${color}"></span><span>${esc(AGENT_LABELS[agent] || agent)}</span><span class="agent-task-count">${count}</span></div>`;
       }).join('');
@@ -330,6 +329,34 @@
 
   function countAllTasks() { return projects.reduce((s, p) => s + (p.taskCount || 0), 0); }
 
+  function getVisibleAgents() {
+    const taskCounts = {};
+    tasks.forEach(t => {
+      if (t.agent) taskCounts[t.agent] = (taskCounts[t.agent] || 0) + 1;
+    });
+
+    const visibleAgents = new Set();
+    const sourceProjects = selectedProjectId
+      ? projects.filter(p => p.id === selectedProjectId)
+      : projects;
+
+    sourceProjects.forEach(project => {
+      (project.activeAgents || project.agents || []).forEach(agent => {
+        if (agent) visibleAgents.add(agent);
+      });
+    });
+
+    Object.keys(taskCounts).forEach(agent => visibleAgents.add(agent));
+
+    return Array.from(visibleAgents)
+      .sort((a, b) => {
+        const countDiff = (taskCounts[b] || 0) - (taskCounts[a] || 0);
+        if (countDiff !== 0) return countDiff;
+        return String(AGENT_LABELS[a] || a).localeCompare(String(AGENT_LABELS[b] || b));
+      })
+      .map(agent => ({ agent, count: taskCounts[agent] || 0 }));
+  }
+
   // ── Board Rendering ────────────────────────
   function renderBoard() {
     const colNames = ['backlog', 'in-progress', 'review', 'done'];
@@ -469,7 +496,7 @@
   function renderDeploys() {
     const container = document.getElementById('deploy-list');
     if (deployments.length === 0) {
-      container.innerHTML = '<div class="deploy-empty">No deployments yet. Deploy from CLI with: <code>codymaster deploy staging</code></div>';
+      container.innerHTML = '<div class="deploy-empty">No deployments yet. Deploy from CLI with: <code>opencode deploy staging</code></div>';
       return;
     }
 
@@ -515,7 +542,7 @@
   function renderChangelog() {
     const container = document.getElementById('changelog-list');
     if (changelog.length === 0) {
-      container.innerHTML = '<div class="changelog-empty">No changelog entries yet. Add one with the button above or CLI: <code>codymaster changelog add</code></div>';
+      container.innerHTML = '<div class="changelog-empty">No changelog entries yet. Add one with the button above or CLI: <code>opencode changelog add</code></div>';
       return;
     }