@rockysoft/opencode-hybrid-workflow 0.0.0-stage → 0.3.2-beta.2

package/lib/settings-service.mjs

@@ -0,0 +1,129 @@
+import {existsSync,readFileSync,writeFileSync,mkdirSync,renameSync} from 'node:fs';
+import path from 'node:path';
+import {createHash,randomUUID} from 'node:crypto';
+import {configDirectory,readSettings,settingsFile,packageRoot} from './config.mjs';
+import {install,parseJsonc,safeTarget} from './install.mjs';
+import {selection} from './select-reviewers.mjs';
+import {commandSpec} from './commands.mjs';
+import {runProcess,requireSubscription} from '../core/workers.mjs';
+import {NativeBrowser} from './native-browser.mjs';
+import {SettingsRPC} from './settings-rpc.mjs';
+const writes=new Set();
+const unwrap=x=>x?.data??x;
+export function revision(file){return createHash('sha256').update(existsSync(file)?readFileSync(file):'missing').digest('hex');}
+export function validateChoices(input,catalog,previous){
+ if(!input.reviewers||Object.keys(input.reviewers).some(k=>!['astra','opus'].includes(k)))throw Error('Choose one or two reviewer slots.');
+ const reviewers={};
+ for(const who of ['astra','opus']){
+  const item=input.reviewers[who];
+  if(item===null&&who==='opus'){reviewers[who]=null;continue;}
+  if(!item||typeof item.model!=='string')throw Error('Reviewer model is required.');
+  if(item.adapter==='opencode')reviewers[who]=selection(`opencode:${item.providerID}/${item.model}`,{catalog,variant:item.variant});
+  else if(['codex-cli','claude-cli'].includes(item.adapter)){
+   if(item.effort&&!/^[a-zA-Z0-9_-]+$/.test(item.effort))throw Error('Invalid reasoning effort.');
+   reviewers[who]=selection(`${item.adapter}:${item.model}`,{previous:previous.reviewers?.[who]??{},variant:item.effort});
+  }else throw Error('Unknown reviewer connection.');
+ }
+ if(!['astra','opus'].includes(input.designAuthor)||!reviewers[input.designAuthor])throw Error('Choose an enabled planning/design lead.');
+ return {reviewers,designAuthor:input.designAuthor};
+}
+export function createSettingsService(ctx,options={}){
+ const root=configDirectory(),file=settingsFile(options);
+ const readOnly=path.resolve(file)!==path.join(root,'hybrid','config.json');
+ const load=()=>readSettings(options);
+ const catalog=async()=>{const values=unwrap(await ctx.model.list({location:ctx.location}));return values.filter(m=>m.enabled&&m.capabilities?.tools&&(!m.type||m.type==='chat'));};
+ const globalFile=()=>{const json=path.join(root,'opencode.json'),jsonc=path.join(root,'opencode.jsonc');if(existsSync(json)&&existsSync(jsonc))throw Error('Both opencode.json and opencode.jsonc exist; resolve the duplicate configuration.');return existsSync(jsonc)?jsonc:json;};
+ const globalRead=()=>existsSync(globalFile())?parseJsonc(readFileSync(safeTarget(root,globalFile()),'utf8')):{};
+ const patchGlobal=update=>{
+  const target=globalFile(),before=existsSync(target)?readFileSync(safeTarget(root,target),'utf8'):null;
+  const value=before?parseJsonc(before):{};update(value);
+  const backup=path.join(root,'backups','hybrid-ui-'+randomUUID());mkdirSync(backup,{recursive:true,mode:0o700});
+  if(before!==null)writeFileSync(path.join(backup,path.basename(target)),before,{mode:0o600});
+  const tmp=target+'.hybrid-'+randomUUID();writeFileSync(tmp,JSON.stringify(value,null,2)+'\n',{mode:0o600});renameSync(tmp,target);
+ };
+ const persist=patch=>install({root,settingsPatch:{...(!existsSync(file)?{setupComplete:false}:{}),...patch},registerPlugin:false});
+ async function exclusive(fn){if(readOnly)throw Error('This installation uses a custom OPENCODE_HYBRID_CONFIG override. It remains active; interactive changes require the standard global configuration location.');if(writes.has(file))throw Error('Another settings change is in progress. Please retry when it finishes.');writes.add(file);try{return await fn();}finally{writes.delete(file);}}
+ async function get(){
+  const config=load(),models=await catalog();
+  return {configured:existsSync(file)&&config.setupComplete!==false,readOnly,revision:revision(file),version:JSON.parse(readFileSync(path.join(packageRoot,'package.json'),'utf8')).version,
+   reviewers:config.reviewers,designAuthor:config.designAuthor??(config.reviewers.opus?'opus':'astra'),browserEnabled:!!config.reviewBrowser?.enabled,
+   catalog:models.map(m=>({providerID:m.providerID,id:m.id,name:m.name,variants:(m.variants??[]).map(v=>v.id),vision:m.capabilities.input?.includes('image')===true})),
+   configFile:file,implementationModel:globalRead().model??'Selected in OpenCode',host:process.platform};
+ }
+ async function diagnostics(){
+  const config=load(),checks=[];
+  const check=async(name,fn)=>{try{checks.push({name,ok:true,detail:await fn()});}catch(e){checks.push({name,ok:false,detail:e.message});}};
+  for(const [name,exe] of [['Node','node'],['Git','git'],['pnpm',config.pnpmExecutable],['Design research Python',config.design.pythonExecutable]])await check(name,async()=>{const spec=commandSpec(exe);return (await runProcess(spec.executable,[...spec.args,'--version'],root,'',15000)).trim().split('\n')[0];});
+  const models=await catalog();
+  for(const [who,lane] of Object.entries(config.reviewers))if(lane)await check(who==='astra'?'Reviewer 1':'Reviewer 2',async()=>{
+   if(lane.adapter==='opencode'){selection(`opencode:${lane.providerID}/${lane.model}`,{catalog:models,variant:lane.variant});return `${lane.providerID} / ${lane.model} / ${lane.variant??'default'}`;}
+   requireSubscription(who,config,root);return `${lane.adapter} signed in`;
+  });
+  if(config.reviewBrowser?.enabled)await check('Reviewer browser',async()=>{
+   const folder=path.join(root,'hybrid','checks',randomUUID());safeTarget(root,folder);mkdirSync(folder,{recursive:true});
+   const browser=new NativeBrowser(config,folder);
+   try{await browser.start();const result=await browser.request('tools/call',{name:'browser_snapshot',arguments:{}});if(result.isError)throw Error((result.content??[]).filter(c=>c.type==='text').map(c=>c.text).join('\n')||'Browser check failed');return 'Isolated browser launched and responded';}finally{await browser.close();}
+  });
+  for(const name of ['frontend-design','ui-ux-pro-max','web-design-guidelines'])await check(name,async()=>{if(!existsSync(path.join(config.design.skillsDirectory,name,'SKILL.md')))throw Error('Bundled skill missing');return 'Available';});
+  return {checks,modelCalls:0};
+ }
+ async function installTool(spec,signal){
+  const folder=path.join(root,'hybrid','tools');safeTarget(root,folder);mkdirSync(folder,{recursive:true,mode:0o700});
+  await runProcess('npm',['install','--prefix',folder,'--ignore-scripts','--no-audit','--no-fund',spec],folder,'',0,signal);
+  return folder;
+ }
+ return {get,diagnostics,
+  save:input=>exclusive(async()=>{
+   if(input.revision!==revision(file))throw Error('Settings changed in another window. Reopen settings and try again.');
+   const patch=validateChoices(input,await catalog(),load());
+   // Recheck after catalog I/O; never overwrite another UI's saved defaults.
+   if(input.revision!==revision(file))throw Error('Settings changed in another window. Reopen settings and try again.');
+   const installed=persist({...patch,setupComplete:true});return {saved:true,preservedCustomFiles:installed.preservedCustomFiles,message:'Saved globally. New tasks use these reviewers; active tasks keep their assignments.'};
+  }),
+  browser:(input,context={})=>exclusive(async()=>{
+   if(input.action==='disable'){persist({reviewBrowser:{...load().reviewBrowser,enabled:false}});return {message:'Reviewer browser disabled for future calls.'};}
+   if(input.action==='enable'){
+    let setting=load().reviewBrowser;
+    if(!setting?.command){
+     const server=globalRead().mcp?.servers?.playwright;
+     if(server?.type!=='local'||!Array.isArray(server.command))throw Error('No installed browser found. Choose Install browser support in this menu.');
+     const stop=server.command.findIndex((x,i)=>i>0&&x.startsWith('--')),command=server.command.slice(0,stop<0?undefined:stop);
+     if(command.some(x=>/^(-y|install|add)$/.test(x)))throw Error('Browser uses on-demand downloads. Choose Install browser support for a managed installation.');
+     const pos=server.command.indexOf('--browser');setting={command,browser:pos>=0?server.command[pos+1]:'chrome',headless:true};
+    }
+    persist({reviewBrowser:{...setting,enabled:true}});return {message:'Browser support enabled.'};
+   }
+   if(input.action!=='install')throw Error('Unknown browser action.');
+   const folder=await installTool('@playwright/mcp@0.0.83',context.signal),node=commandSpec('node');
+   await runProcess(node.executable,[...node.args,path.join(folder,'node_modules','playwright','cli.js'),'install','firefox'],folder,'',0,context.signal);
+   const command=[node.executable,...node.args,path.join(folder,'node_modules','@playwright','mcp','cli.js')];
+   persist({reviewBrowser:{enabled:true,command,browser:'firefox',headless:true}});
+   patchGlobal(value=>{value.mcp??={};value.mcp.servers??={};value.mcp.servers.playwright??={type:'local',command:[...command,'--browser','firefox','--isolated','--headless'],enabled:true};});
+   return {message:'Playwright and Firefox installed. Reviewer browser enabled; implementation MCP configured unless one already existed.'};
+  }),
+  dependencies:(input,context={})=>exclusive(async()=>{
+   if(input.action==='pnpm'){
+    const folder=await installTool('pnpm@12.14.0',context.signal);
+    // pnpm 12 ships a native binary; only run this explicitly selected package's
+    // installer, then verify it before saving a working executable.
+    const node=commandSpec('node'),packageFolder=path.join(folder,'node_modules','pnpm');
+    await runProcess(node.executable,[...node.args,path.join(packageFolder,'install.js')],folder,'',0,context.signal);
+    const executable=path.join(packageFolder,process.platform==='win32'?'pnpm.exe':'pnpm');
+    await runProcess(executable,['--version'],folder,'',15000,context.signal);
+    persist({verification:{...load().verification,executable}});
+    return {message:'Managed pnpm installed for hybrid verification. Project-required versions still take precedence.'};
+   }
+   if(input.action==='context7'){
+    patchGlobal(value=>{value.mcp??={};value.mcp.servers??={};value.mcp.servers.context7??={type:'remote',url:'https://mcp.context7.com/mcp',enabled:true};});
+    return {message:'Context7 documentation MCP configured. Any existing configuration was preserved.'};
+   }
+   throw Error('Unknown dependency.');
+  }),
+ };
+}
+export async function registerSettings(ctx,options){
+ const service=createSettingsService(ctx,options);
+ // Expected setup errors must reach the dialog, not become opaque HTTP defects.
+ const handlers=Object.fromEntries(Object.entries(service).map(([name,fn])=>[name,async(...args)=>{try{return await fn(...args);}catch(error){return {error:{message:error.message}};}}]));
+ await ctx.rpc.register(SettingsRPC,handlers);return service;
+}

package/package.json

@@ -1,6 +1,64 @@
-{
-  "name": "@rockysoft/opencode-hybrid-workflow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@rockysoft/opencode-hybrid-workflow",
+  "version": "0.3.2-beta.2",
+  "description": "Portable configurable-reviewer planning, design, implementation checkpoints and usage sidebar for OpenCode 2",
+  "type": "module",
+  "license": "MIT",
+  "author": "RockySoft",
+  "keywords": ["opencode", "opencode-plugin", "agents", "code-review", "workflow"],
+  "publishConfig": { "access": "public", "tag": "beta" },
+  "exports": {
+    ".": "./index.js",
+    "./tui": "./tui.js"
+  },
+  "bin": {
+    "opencode-hybrid": "./cli.mjs"
+  },
+  "files": [
+    "index.js",
+    "tui.js",
+    "cli.mjs",
+    "lib/",
+    "core/",
+    "sidebar/",
+    "assets/",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE",
+    "docs/"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build",
+    "test": "node --test test/*.test.mjs",
+    "doctor": "node cli.mjs doctor"
+  },
+  "devDependencies": {
+    "@babel/core": "7.29.7",
+    "@babel/preset-typescript": "7.27.1",
+    "babel-preset-solid": "1.9.12"
+  },
+  "peerDependencies": {
+    "@opencode/plugin": ">=2.1.2 <3",
+    "@opentui/core": ">=0.6.6",
+    "@opentui/solid": ">=0.6.6",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode/plugin": {
+      "optional": true
+    },
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  }
+}

package/sidebar/reader.mjs

@@ -0,0 +1,80 @@
+import { readFile, realpath, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { reportedUsage, priceCall } from '../core/pricing.mjs';
+import { summarize, countedCalls } from '../core/dashboard-state.js';
+import { runtimeFor } from '../lib/config.mjs';
+
+export const projectKey = directory => createHash('sha256').update(process.platform==='win32'?directory.toLowerCase():directory).digest('hex').slice(0,24);
+export const number = value => value == null ? 'Unavailable' : value.toLocaleString('en-US');
+export function money(cost) {
+  if (!cost) return 'Unavailable';
+  const usd = n => '$' + n.toFixed(2);
+  return Math.abs(cost.high-cost.low) < .005 ? usd(cost.low) : usd(cost.low) + '–' + usd(cost.high);
+}
+export function cards(snapshot, reset) {
+  return summarize(countedCalls(snapshot.calls, reset), snapshot.efforts).filter(total=>snapshot.models?.[total.who]||snapshot.calls.some(c=>c.who===total.who)||!snapshot.models).map(total => {
+    const active = snapshot.calls.filter(c => c.who === total.who && !c.endedAt && ['running','preparing','stale'].includes(c.status));
+    const names=[...new Set(snapshot.calls.filter(c=>c.who===total.who).map(c=>c.requestedModel).filter(Boolean))];
+    const efforts=[...new Set(snapshot.calls.filter(c=>c.who===total.who).map(c=>c.effort).filter(Boolean))];
+    return { ...total,effort:efforts.length?efforts.join(' / '):total.effort, model:names.length?names.join(' / '):snapshot.models?.[total.who],status: active.some(c => c.status === 'stale') ? 'Status stale' : active.length ? 'Running' : 'Idle',
+      partial: total.measuredCalls < total.calls || total.pricedCalls < total.calls };
+  });
+}
+
+// Read only this project's existing telemetry, never prompts, credentials, or source.
+// No HTTP server, child processes, model requests, or checkpoint writes.
+export function createReader(settings) {
+  const cache = new Map();
+  async function json(file) {
+    const info = await stat(file);
+    const key = `${info.mtimeMs}:${info.size}`;
+    const old = cache.get(file);
+    if (old?.key === key) return old.value;
+    const value = JSON.parse(await readFile(file, 'utf8'));
+    cache.set(file, { key, value });
+    if (cache.size > 512) cache.delete(cache.keys().next().value);
+    return value;
+  }
+  async function contained(root, file) {
+    const resolved = await realpath(file);
+    const relative = path.relative(root, resolved);
+    if (relative === '..' || relative.startsWith('..'+path.sep) || path.isAbsolute(relative)) throw new Error('Telemetry path outside runtime');
+    return resolved;
+  }
+  return async directory => {
+    if (typeof directory !== 'string' || !path.isAbsolute(directory)) throw new Error('Project location unavailable');
+    const project = await realpath(directory);
+    const efforts = settings.efforts;
+    const empty = { project, task: null, key: projectKey(project), calls: [], efforts, models:settings.models };
+    let runtime, folder, state;
+    try {
+      runtime = await realpath(runtimeFor(settings,project));
+      folder = await contained(runtime, path.join(runtime, projectKey(project)));
+      state = await json(await contained(runtime, path.join(folder, 'state.json')));
+    } catch (error) { if (error.code === 'ENOENT') return empty; throw error; }
+    if (!/^[a-f0-9-]{36}$/i.test(state.id)) throw new Error('Invalid telemetry task');
+    const normalize=p=>process.platform==='win32'?p.toLowerCase():p;
+    if (!state.baseline?.root || normalize(await realpath(state.baseline.root)) !== normalize(project)) throw new Error('Project telemetry does not match current project');
+    const result = { ...empty, task: state.id, key: `${empty.key}:${state.id}` };
+    let taskFolder;
+    try { taskFolder = await contained(runtime, path.join(folder, state.id)); }
+    catch (error) { if (error.code === 'ENOENT') return result; throw error; }
+    const names = (await readdir(taskFolder)).filter(name => /^\d+-(astra|opus)-[a-z0-9-]+$/.test(name)).sort((a,b) => parseInt(a)-parseInt(b));
+    for (const name of names) {
+      const who = /^\d+-(astra|opus)-/.exec(name)[1];
+      let activity;
+      try { activity = await json(await contained(runtime, path.join(taskFolder, name, 'activity.json'))); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+      let status = activity?.status ?? 'unknown';
+      if (['running','preparing'].includes(status) && !(Date.now()-Date.parse(activity.updatedAt) <= 30000)) status = 'stale';
+      const call = { id: name, who, status, endedAt: activity?.endedAt ?? null,
+        effort:activity?.effort,requestedModel: activity?.requestedModel ?? settings.models[who], resolvedModels: activity?.resolvedModels ?? [],
+        apiCost:activity?.apiCost,usage: activity?.usage ?? null, usageByModel: activity?.usageByModel ?? {} };
+      call.usage = reportedUsage(call);
+      call.cost = priceCall(call);
+      result.calls.push(call);
+    }
+    return result;
+  };
+}

package/sidebar/settings.mjs

@@ -0,0 +1,99 @@
+import {SettingsRPC} from '../lib/settings-rpc.mjs';
+const unwrap=value=>value?.data??value;
+const label=lane=>lane?`${lane.adapter==='opencode'?lane.providerID:lane.adapter} / ${lane.model} / ${lane.variant??lane.effort??'default'}`:'Disabled';
+export function createSettingsUI(context,onSaved=()=>{}){
+ const rpc=context.client.rpc(SettingsRPC);let open=false,disposed=false;
+ const select=(title,options,current)=>context.ui.dialog.select({title,current,options});
+ const alert=(title,message)=>context.ui.dialog.alert({title,message});
+ async function invoke(method,input={}){const response=await rpc[method](input),value=unwrap(response);const error=response?.error??value?.error;if(error)throw Error(typeof error==='string'?error:error.message??'OpenCode could not complete this settings operation.');return value;}
+ function dispatch(name){
+  const commands=context.keymap.commands();
+  const command=commands.find(c=>c.slash?.name===name||c.slash?.aliases?.includes(name));
+  if(!command)throw Error(`OpenCode's ${name} menu is unavailable in this version.`);
+  context.keymap.dispatch(command.id);
+ }
+ async function reviewer(who,state,current){
+  const connection=await select(`Reviewer ${who==='astra'?1:2}: connection`,[{title:'OpenCode connected provider',value:'opencode',description:'Use an account already connected to OpenCode'},{title:'External CLI',value:'cli',description:'Codex CLI or Claude Code CLI login'}],!state.configured||current?.adapter==='opencode'?'opencode':'cli');
+  if(!connection)return;
+  if(connection==='opencode'){
+   const providers=[...new Set(state.catalog.map(m=>m.providerID))];
+   if(!providers.length){await alert('Connect a provider','No connected tool-capable models are available. Use Connect provider in Hybrid settings, then try again.');return;}
+   const provider=await select('Provider',providers.map(id=>({title:id,value:id})),current?.providerID);if(!provider)return;
+   const model=await select('Reviewer model',state.catalog.filter(m=>m.providerID===provider).map(m=>({title:m.name??m.id,value:m.id,description:m.id+(m.vision?' · images supported':' · text only')})),current?.model);if(!model)return;
+   const chosen=state.catalog.find(m=>m.providerID===provider&&m.id===model);
+   const variant=await select('Reasoning effort',[{title:'Provider default',value:'__default'},...chosen.variants.map(v=>({title:v,value:v}))],current?.variant??'__default');if(!variant)return;
+   return {adapter:'opencode',providerID:provider,model,...(variant==='__default'?{}:{variant})};
+  }
+  const adapter=await select('External CLI',[{title:'Codex CLI',value:'codex-cli'},{title:'Claude Code CLI',value:'claude-cli'}],current?.adapter);if(!adapter)return;
+  const model=await context.ui.dialog.prompt({title:'CLI model',placeholder:current?.adapter===adapter?current.model:adapter==='codex-cli'?'gpt-6-astra':'opus',value:current?.adapter===adapter?current.model:adapter==='codex-cli'?'gpt-6-astra':'opus'});if(!model?.trim())return;
+  const effort=await select('CLI reasoning effort',['low','medium','high','xhigh','max'].map(v=>({title:v,value:v})),current?.effort??'high');if(!effort)return;
+  return {adapter,model:model.trim(),effort};
+ }
+ async function wizard(state){
+  const count=await select('Hybrid setup: reviewers',[{title:'Two reviewers',value:2,description:'Independent planning and review'},{title:'One reviewer',value:1,description:'A single premium planner/reviewer'}],state.reviewers.opus?2:1);if(!count)return;
+  const first=await reviewer('astra',state,state.reviewers.astra);if(!first)return;
+  const second=count===2?await reviewer('opus',state,state.reviewers.opus):null;if(count===2&&!second)return;
+  const lead=count===1?'astra':await select('Planning and design lead',[{title:first.model,value:'astra',description:'Reviewer 1'},{title:second.model,value:'opus',description:'Reviewer 2'}],state.designAuthor);if(!lead)return;
+  const confirmed=await context.ui.dialog.confirm({title:'Save Hybrid setup',message:`Reviewer 1: ${label(first)}\nReviewer 2: ${label(second)}\nPlanning/design lead: ${lead==='astra'?first.model:second.model}\n\nSave for all projects. Active tasks retain their existing reviewers.`,label:{confirm:'Save',cancel:'Cancel'}});
+  if(!confirmed)return;
+  const result=await invoke('save',{revision:state.revision,reviewers:{astra:first,opus:second},designAuthor:lead});
+  onSaved();await alert('Hybrid setup saved',result.message+(result.preservedCustomFiles?.length?'\nExisting customized agents and skills were preserved.':''));
+ }
+ async function browser(state){
+  const action=await select('Reviewer browser',[
+   {title:state.browserEnabled?'Disable browser access':'Enable existing browser',value:state.browserEnabled?'disable':'enable'},
+   {title:'Install browser support',value:'install',description:'Download managed Playwright MCP and Firefox; enable reviewer access'},
+  ]);if(!action)return;
+  if(action==='install'&&!await context.ui.dialog.confirm({title:'Install browser support',message:'Download Playwright MCP and Firefox on the OpenCode server machine? Existing browser settings and user profiles will be preserved.',label:{confirm:'Install',cancel:'Cancel'}}))return;
+  context.ui.toast.show({message:action==='install'?'Installing browser support…':'Updating browser settings…',variant:'info'});
+  const result=await invoke('browser',{action});onSaved();await alert('Reviewer browser',result.message);
+ }
+ async function dependencies(){
+  const action=await select('Tools and dependencies',[
+   {title:'Install pnpm for verification',value:'pnpm',description:'Managed installation; does not replace your global pnpm'},
+   {title:'Enable Context7 documentation',value:'context7',description:'Configure official remote documentation MCP'},
+   {title:'System prerequisites',value:'system',description:'Node, Git, Python and optional CLI login guidance'},
+  ]);if(!action)return;
+  if(action==='system'){await alert('System prerequisites','OpenCode and Node 22+ are required. Git is needed for projects; Python 3 supports design research. External CLI choices also require that CLI and its official login. Diagnostics identifies what is missing. System installers and account sign-in remain machine/account setup; the plugin never copies credentials.');return;}
+  if(!await context.ui.dialog.confirm({title:'Set up dependency',message:action==='pnpm'?'Install managed pnpm on the OpenCode server?':'Add the official Context7 documentation MCP? Existing settings are preserved.',label:{confirm:'Set up',cancel:'Cancel'}}))return;
+  context.ui.toast.show({message:'Setting up dependency…',variant:'info'});const result=await invoke('dependencies',{action});await alert('Dependency setup',result.message);
+ }
+ async function show(firstRun=false){
+  if(open||disposed)return;open=true;
+  try{
+   let state=await invoke('get');
+   if(firstRun&&state.configured)return;
+   if(!state.configured){await wizard(state);state=await invoke('get');}
+   while(!disposed){
+    const action=await select(`Hybrid Workflow ${state.version}`, [
+     {title:state.configured?'Reviewers and design lead':'Complete setup',value:'reviewers',description:label(state.reviewers.astra)+' | '+label(state.reviewers.opus)},
+     {title:'Connect provider',value:'connect',description:'Open OpenCode’s account connection menu'},
+     {title:'Implementation model',value:'models',description:'Select the model that builds your code in OpenCode'},
+     {title:'Reviewer browser',value:'browser',description:state.browserEnabled?'Enabled · isolated sessions':'Disabled'},
+     {title:'Tools and dependencies',value:'dependencies',description:'Browser installation is in Reviewer browser'},
+     {title:'Run diagnostics',value:'diagnostics',description:'Check setup and logins without model calls'},
+     {title:'About this setup',value:'about',description:'Global configuration and active-task behavior'},
+    ]);
+    if(!action)return;
+    try{
+     if(action==='reviewers')await wizard(state);
+     else if(action==='connect'||action==='models'){dispatch(action);return;}
+     else if(action==='browser')await browser(state);
+     else if(action==='dependencies')await dependencies();
+     else if(action==='diagnostics'){
+      context.ui.toast.show({message:'Checking Hybrid setup…',variant:'info'});
+      const report=await invoke('diagnostics');
+      while(!disposed){
+       const item=await select('Hybrid diagnostics',report.checks.map((c,i)=>({title:`${c.ok?'OK':'Needs attention'} · ${c.name}`,value:String(i),description:c.detail.split('\n')[0]})));
+       if(item===undefined||item===null)break;
+       const check=report.checks[Number(item)];await alert(check.name,check.detail);
+      }
+     }else if(action==='about')await alert('Hybrid Workflow',`Global settings: ${state.configFile}\nServer platform: ${state.host}\nNew tasks use saved defaults. Active tasks preserve assigned reviewers, findings and history.\nAt least one pass and no unresolved medium/high/critical findings are required.\nSkills and agent rules are installed when setup is saved. No separate dashboard is needed.`);
+    }catch(error){await alert('Hybrid settings',error.message);}
+    state=await invoke('get');
+   }
+  }catch(error){context.ui.toast.show({message:'Hybrid settings: '+error.message,variant:'error'});}
+  finally{open=false;}
+ }
+ return {show,dispose(){disposed=true;},rpc};
+}