@rockysoft/opencode-hybrid-workflow 0.6.0 → 0.7.0

package/README.md

@@ -176,5 +176,5 @@ Remove the old plugin entries from `opencode.json` and `cli.json` before adding
 </details>
 
 [Advanced configuration](https://cdn.jsdelivr.net/npm/@rockysoft/opencode-hybrid-workflow@0.4.0/docs/configuration.md) · [MIT license](https://cdn.jsdelivr.net/npm/@rockysoft/opencode-hybrid-workflow@0.4.0/LICENSE) · [Third-party notices](https://cdn.jsdelivr.net/npm/@rockysoft/opencode-hybrid-workflow@0.4.0/THIRD_PARTY_NOTICES.md)
-
-For deterministic Vitest projects, see [faster verification](https://cdn.jsdelivr.net/npm/@rockysoft/opencode-hybrid-workflow@0.6.0/docs/verification.md). Full checks remain the default.
+
+For deterministic Vitest projects, see [faster verification](https://cdn.jsdelivr.net/npm/@rockysoft/opencode-hybrid-workflow@0.7.0/docs/verification.md). Full checks remain the default; eligible projects automatically choose full checks when measured optimization overhead is higher.

package/docs/CHANGELOG.md

@@ -1,12 +1,21 @@
-# Release notes
-
-## 0.6.0
-
-- Reuse verified full test results when declared deterministic inputs are unchanged.
-- Run affected Vitest tests for known static source changes, with full checks as the fallback.
-- Clearly distinguish fresh, reused and targeted results.
-
-Full checks remain the default. [Set up faster verification](./verification.md) for eligible projects; reviewer approval rules are unchanged.
+# Release notes
+
+## 0.7.0
+
+- Choose full or optimized verification automatically from measured execution and input-checking costs.
+- Avoid dependency hashing when ordinary full checks are faster; reconsider when the suite grows.
+- Learn when a targeted test selection costs more than a full run.
+- Keep timing-history failures from interrupting verification.
+
+Existing deterministic verification contracts work without new settings. Projects without a contract continue to run full checks.
+
+## 0.6.0
+
+- Reuse verified full test results when declared deterministic inputs are unchanged.
+- Run affected Vitest tests for known static source changes, with full checks as the fallback.
+- Clearly distinguish fresh, reused and targeted results.
+
+Full checks remain the default. [Set up faster verification](./verification.md) for eligible projects; reviewer approval rules are unchanged.
 
 ## 0.5.0
 

package/docs/verification.md

@@ -1,52 +1,60 @@
-# Faster verification
-
-Full checks work as before. For deterministic **Vitest 4** projects, Hybrid can reuse an unchanged full result or run tests related to a known source change. It always labels which happened. Reviewer approval remains separate.
-
-Ask your planning agent to establish the input contract from your actual tests and dependencies. Keep full checks if those assumptions cannot be established. This first adapter supports exactly `"test": "vitest run"`, without `pretest` or `posttest`; other scripts still execute normally.
-
-Example in the project's `package.json`:
-
-```json
-{
-  "scripts": { "test": "vitest run" },
-  "hybrid": {
-    "verification": {
-      "version": 1,
-      "scripts": {
-        "test": {
-          "runner": "vitest",
-          "deterministic": true,
-          "externalInputs": false,
-          "unrelatedDocuments": ["README.md"],
-          "outputs": ["node_modules/.vite"],
-          "relatedSources": ["src/money.ts"]
-        }
-      }
-    }
-  }
-}
-```
-
-These are **explicit project assertions**, not conclusions inferred by the plugin:
-
-- `deterministic`: the same inputs produce the same test outcome. Time, randomness and external service state must not affect it.
-- `externalInputs: false`: tests read only bound project files, installed dependencies and the child process environment. Git history/status, user-home files, OS services, global tools launched by tests and other undeclared external state are not covered. Such checks must run fresh.
-- `unrelatedDocuments`: literal Markdown/text files proven not to affect any test. No globs. All other project files, including Git-ignored fixtures and `.env`, are fingerprinted.
-- `outputs`: disposable output directories that tests never use as inputs. Supported: `coverage`, `node_modules/.vite`, `node_modules/.vite-temp`. Never exclude test fixtures or source. Output exclusion is an assertion; a test that reads its prior cache is not eligible.
-- `relatedSources`: existing implementation modules with a known static import relationship to tests, including transitive consumers. Do not declare modules with computed imports, runtime file loading, global side effects across test files, custom loader dependencies or dependencies outside Vitest's graph. A conservative scan rejects common dynamic-loading cases; it is **not a general dependency proof**. Omit this list when unsure; unchanged-input reuse still works.
-
-Every optimization starts with a successful, complete, nonempty full Vitest run. The receipt binds the project, contract, complete nonexcluded file inventory, installed dependency bytes, file permissions, lockfiles, configuration, Node/platform, pnpm implementation and child environment. Secrets are hashed, never copied into receipts. Raw test output can still contain what your tests print, just as with ordinary verification.
-
-An exact match may reuse the previous result and reports its original execution time. Changes limited to declared static sources may run `vitest related --run`; that result is **selected-tests-only**, not a full-suite pass. An empty selection falls back to full verification. Unknown/new/deleted files, changed tests/fixtures/configuration, toolchain or environment changes use a full run. External links or unsupported launchers disable optimization. A failed fresh full attempt invalidates the older success. Reuse is local to the project; nothing is uploaded to a cache service.
-
-For a fresh full check, the agent calls:
-
-```json
-{ "action": "verify", "script": "test", "verificationMode": "full" }
-```
-
-Use fresh full checks for final acceptance or whenever the dependency assumptions are uncertain. Existing typecheck, lint and build scripts still run in full. No verification result grants reviewer approval, and no automatic model or environment changes are made.
-
-Hashing dependencies has a cost; small suites may gain little or nothing from targeting. Validate elapsed time on your project. Browser scenario/evidence reuse is a separate feature and is not included here.
-
-Reference: [Vitest related CLI and its static import limitations](https://vitest.dev/guide/cli.html#vitest-related).
+# Faster verification
+
+Full checks work as before. For deterministic **Vitest 4** projects, Hybrid can reuse an unchanged full result or run tests related to a known source change. It always labels which happened. Reviewer approval remains separate.
+
+Ask your planning agent to establish the input contract from your actual tests and dependencies. Keep full checks if those assumptions cannot be established. This first adapter supports exactly `"test": "vitest run"`, without `pretest` or `posttest`; other scripts still execute normally.
+
+Example in the project's `package.json`:
+
+```json
+{
+  "scripts": { "test": "vitest run" },
+  "hybrid": {
+    "verification": {
+      "version": 1,
+      "scripts": {
+        "test": {
+          "runner": "vitest",
+          "deterministic": true,
+          "externalInputs": false,
+          "unrelatedDocuments": ["README.md"],
+          "outputs": ["node_modules/.vite"],
+          "relatedSources": ["src/money.ts"]
+        }
+      }
+    }
+  }
+}
+```
+
+These are **explicit project assertions**, not conclusions inferred by the plugin:
+
+- `deterministic`: the same inputs produce the same test outcome. Time, randomness and external service state must not affect it.
+- `externalInputs: false`: tests read only bound project files, installed dependencies and the child process environment. Git history/status, user-home files, OS services, global tools launched by tests and other undeclared external state are not covered. Such checks must run fresh.
+- `unrelatedDocuments`: literal Markdown/text files proven not to affect any test. No globs. All other project files, including Git-ignored fixtures and `.env`, are fingerprinted.
+- `outputs`: disposable output directories that tests never use as inputs. Supported: `coverage`, `node_modules/.vite`, `node_modules/.vite-temp`. Never exclude test fixtures or source. Output exclusion is an assertion; a test that reads its prior cache is not eligible.
+- `relatedSources`: existing implementation modules with a known static import relationship to tests, including transitive consumers. Do not declare modules with computed imports, runtime file loading, global side effects across test files, custom loader dependencies or dependencies outside Vitest's graph. A conservative scan rejects common dynamic-loading cases; it is **not a general dependency proof**. Omit this list when unsure; unchanged-input reuse still works.
+
+Every optimization starts with a successful, complete, nonempty full Vitest run. The receipt binds the project, contract, complete nonexcluded file inventory, installed dependency bytes, file permissions, lockfiles, configuration, Node/platform, pnpm implementation and child environment. Secrets are hashed, never copied into receipts. Raw test output can still contain what your tests print, just as with ordinary verification.
+
+An exact match may reuse the previous result and reports its original execution time. Changes limited to declared static sources may run `vitest related --run`; that result is **selected-tests-only**, not a full-suite pass. An empty selection falls back to full verification. Unknown/new/deleted files, changed tests/fixtures/configuration, toolchain or environment changes use a full run. External links or unsupported launchers disable optimization. A failed fresh full attempt invalidates the older success. Reuse is local to the project; nothing is uploaded to a cache service.
+
+For a fresh full check, the agent calls:
+
+```json
+{ "action": "verify", "script": "test", "verificationMode": "full" }
+```
+
+Use fresh full checks for final acceptance or whenever the dependency assumptions are uncertain. Existing typecheck, lint and build scripts still run in full. No verification result grants reviewer approval, and no automatic model or environment changes are made.
+
+## Automatic cost choice
+
+Once a project has the contract above, no speed settings are needed. The first run measures full execution and the additional input-binding work. Later runs choose ordinary full checks without that hashing when it costs at least as much as running the suite. Supported Vitest runs still validate a complete, nonempty passing report.
+
+Ordinary runs keep measuring execution time. If the suite grows enough to make optimization worthwhile, Hybrid recalibrates and can reuse unchanged results again. A new targeted selection is measured on its first use; if selection plus binding is slower than full execution, later matching corrections use full checks instead.
+
+Results include the reason, execution time and input-binding time. Timing history is a local performance hint, never evidence of correctness or reviewer approval. A missing or invalid history causes calibration; a failed history write does not discard the check result. A forced full check skips optimization hashing and does not create a reusable receipt.
+
+The initial calibration and a first targeted trial can be slower. Decisions use previous observations, so machine load and changing workloads can still affect the next run; this is not a promise that every call will be faster. Browser scenario/evidence reuse is a separate feature and is not included here.
+
+Reference: [Vitest related CLI and its static import limitations](https://vitest.dev/guide/cli.html#vitest-related).

package/lib/verification/costs.mjs

@@ -0,0 +1,55 @@
+import {readFileSync} from 'node:fs';
+import {hash} from '../../core/snapshot.mjs';
+import {writeJSONAtomic} from '../../core/state-store.mjs';
+
+// Performance hints never establish correctness. Choosing ordinary verification
+// needs no content fingerprint; choosing reuse/selection still needs every guard.
+export function costKey(root,script,manifest,contract,executable,environment) {
+ return hash(JSON.stringify([root,script,manifest,contract,executable,process.version,process.platform,process.arch,Object.entries(environment).sort(([a],[b])=>a.localeCompare(b))]));
+}
+const milliseconds=value=>Number.isFinite(value)&&value>=0;
+export function loadCosts(file,key) {
+ try {
+  const {checksum,...value}=JSON.parse(readFileSync(file,'utf8'));
+  if(value.schema!==1||value.key!==key||!milliseconds(value.fullMs)||!milliseconds(value.bindingMs)||!value.targets||!value.targetHints||[value.targets,value.targetHints].some(map=>typeof map!=='object'||Array.isArray(map)||Object.entries(map).some(([k,v])=>!(/^[a-f0-9]{64}$/.test(k))||!milliseconds(v)))||checksum!==hash(JSON.stringify(value)))return null;
+  return value;
+ }catch{return null;}
+}
+export function sourceHints(tree,contract){return Object.fromEntries(contract.relatedSources.map(name=>[name,tree.files[name]?.hash??null]));}
+export function targetHint(tree,contract,sources){return hash(JSON.stringify([sources,Object.entries(tree.files).filter(([name])=>!contract.relatedSources.includes(name)&&!contract.unrelatedDocuments.includes(name)).map(([name,file])=>[name,file.hash])]));}
+export function ordinaryReason(mode,costs,tree,contract) {
+ if(mode==='full')return 'Fresh full verification requested; skipping optimization overhead.';
+ if(costs&&costs.fullMs<=costs.bindingMs)return 'Measured full execution is no slower than input binding; running ordinary full checks without fingerprinting.';
+ if(costs?.baselineSources&&contract){
+  const sources=contract.relatedSources.filter(name=>(tree.files[name]?.hash??null)!==costs.baselineSources[name]);
+  const elapsed=costs.targetHints[targetHint(tree,contract,sources)];
+  if(sources.length&&elapsed!==undefined&&costs.bindingMs+elapsed>=costs.fullMs)return 'Previous measurements for these changed sources favor ordinary full checks; skipping fingerprinting.';
+ }
+ return null;
+}
+export function selectionKey(inputs,contract,sources) {
+ // Preserve measurements across source corrections, but discard them when test
+ // selection inputs (tests/config/fixtures/dependencies/toolchain) change.
+ return hash(JSON.stringify([inputs.bindingHash,sources,Object.entries(inputs.files).filter(([name])=>!contract.relatedSources.includes(name)),inputs.directories,inputs.links]));
+}
+export function cheaperPlan(plan,inputs,contract,costs) {
+ if(!costs)return {scope:'full',reason:'Measuring full execution and input-binding costs before choosing optimization.'};
+ if(plan.scope!=='targeted')return plan;
+ const targetKey=selectionKey(inputs,contract,plan.sources);
+ const targetMs=costs.targets[targetKey];
+ if(targetMs!==undefined&&costs.bindingMs+targetMs>=costs.fullMs)return {scope:'full',reason:'Measured targeted execution plus input binding is not cheaper than a full run.',targetKey};
+ return {...plan,targetKey,reason:plan.reason+(targetMs===undefined?' Measuring this selection for future cost decisions.':' Previous measurements predict a saving.')};
+}
+export function observeCosts(file,key,previous,record,tree,contract) {
+ if(!record.success||record.inputChangedDuringRun||record.modifiedFiles)return;
+ const measured=record.timings;
+ const fullMs=record.scope==='full'&&record.execution==='executed'?measured.executionMs:previous?.fullMs;
+ const bindingMs=record.inputFingerprint?measured.inputBindingMs:previous?.bindingMs;
+ if(!milliseconds(fullMs)||!milliseconds(bindingMs))return;
+ const targets={...previous?.targets};
+ const targetHints={...previous?.targetHints};
+ if(record.scope==='targeted'&&record.costTargetKey){targets[record.costTargetKey]=measured.executionMs;targetHints[record.costTargetHint]=measured.executionMs;}
+ const baselineSources=record.scope==='full'&&record.execution==='executed'?sourceHints(tree,contract):previous?.baselineSources;
+ const value={schema:1,key,fullMs,bindingMs,targets,targetHints,baselineSources,observedAt:record.at};
+ writeJSONAtomic(file,{...value,checksum:hash(JSON.stringify(value))});
+}

package/lib/verification/runner.mjs

@@ -8,26 +8,43 @@ import {runtimePath} from '../../core/state-store.mjs';
 import {contractFor,captureInputs} from './inputs.mjs';
 import {planVerification} from './planner.mjs';
 import {loadReceipt,saveReceipt,invalidateReceipt,testResult} from './receipt.mjs';
+import {costKey,loadCosts,ordinaryReason,cheaperPlan,observeCosts,targetHint} from './costs.mjs';
 
-export async function verifyScript(controller,state,script,signal,mode='auto',execute=runProcess) {
+export async function verifyScript(controller,state,script,signal,mode='auto',execute=runProcess,{now=()=>performance.now()}={}) {
  if(signal?.aborted)throw Error('Cancelled before verification.');
  if(!['auto','full'].includes(mode))throw Error('verificationMode must be auto or full.');
  if(!['typecheck','lint','test','build'].includes(script))throw Error('Verification supports only pnpm run typecheck/lint/test/build, with no arbitrary arguments.');
  const root=controller.directory,config=controller.config;
  const manifest=JSON.parse(readFileSync(path.join(root,'package.json'),'utf8'));
  if(typeof manifest.scripts?.[script]!=='string')throw Error(`No ${script} script in package.json.`);
- const started=performance.now(),before=snapshot(root).fingerprint;
+ const started=now(),beforeTree=snapshot(root),before=beforeTree.fingerprint;
  const id=randomUUID(),record={id,script,command:manifest.scripts[script],before,at:new Date().toISOString(),success:false,scope:'full',execution:'executed'};
  const span=controller.trace?.span('verification',{script});
  const receiptFile=runtimePath(controller.folder,`verification-${script}.json`);
  const {contract,reason}=contractFor(manifest,script);
+ // Report validation is independent of the expensive reusable-input binding.
+ let structured=false;
+ if(contract)try{structured=/^4\./.test(JSON.parse(readFileSync(path.join(root,'node_modules/vitest/package.json'),'utf8')).version);}catch{}
+ let costsFile,costWarning;
+ try{costsFile=runtimePath(controller.folder,`verification-${script}-costs.json`);}catch{costWarning='Timing history unavailable; verification continues without saved cost hints.';}
+ const environment=workerEnvironment(),key=contract?costKey(root,script,manifest,contract,config.pnpmExecutable,environment):null;
+ const costs=key&&costsFile?loadCosts(costsFile,key):null;
+ const ordinary=ordinaryReason(mode,costs,beforeTree,contract);
+ record.timings={executionMs:0,inputBindingMs:0};
+ record.costDecision=ordinary?'ordinary':contract?'calibrating-or-optimized':'unsupported';
+ record.costEstimate=costs?{fullExecutionMs:costs.fullMs,inputBindingMs:costs.bindingMs}:null;
+ const capture=()=>{const at=now();try{return captureInputs(root,contract,config.pnpmExecutable,workerEnvironment());}finally{record.timings.inputBindingMs+=now()-at;}};
  let inputs,plan={scope:'full',reason},receipt;
- if(contract)try {
-  inputs=captureInputs(root,contract,config.pnpmExecutable,workerEnvironment());
+ if(ordinary)plan={scope:'full',reason:ordinary};
+ else if(contract)try {
+  inputs=capture();
   receipt=loadReceipt(receiptFile);
   plan=planVerification({root,mode,contract,inputs,receipt});
+  plan=cheaperPlan(plan,inputs,contract,costs);
  }catch{plan={scope:'full',reason:'Inputs or toolchain could not be fully bound; running the full script.'};inputs=null;}
  record.reason=plan.reason;record.scope=plan.scope;
+ record.costTargetKey=plan.targetKey??null;
+ record.costTargetHint=plan.scope==='targeted'?targetHint(beforeTree,contract,plan.sources):null;
  if(plan.reuse) {
   record.success=true;record.execution='reused';record.sourceReceipt=receipt.id;record.executedAt=receipt.at;record.testCount=receipt.testCount;
   record.output='Reused a prior full-run result under the declared deterministic input contract; no tests ran now.';
@@ -38,25 +55,26 @@ export async function verifyScript(controller,state,script,signal,mode='auto',ex
   const folder=runtimePath(controller.folder,'verification',id);mkdirSync(folder,{recursive:true,mode:0o700});
   const reportFile=runtimePath(controller.folder,'verification',id,'vitest.json');
   let args=plan.scope==='targeted'?['exec','vitest','related','--run',...plan.sources]:['run',script];
-  if(inputs)args.push('--reporter=json',`--outputFile=${reportFile}`);
+  if(structured)args.push('--reporter=json',`--outputFile=${reportFile}`);
   record.arguments=args;
+  const executionStart=now();
   try {
    record.output=await execute(config.pnpmExecutable,args,root,'',config.verificationTimeoutMs??0,signal,{streamOnly:true,captureStderr:true});
    record.success=true;record.exitCode=0;
-   if(inputs) {
+   if(structured) {
     try {const result=testResult(reportFile,root);record.tests=result.tests;record.testCount=result.count;}
     catch {record.success=false;record.error='Vitest did not report a complete nonempty passing selection. Run a full check and inspect its report.';}
    }
   } catch(error) {
    if(error.unreapedPid){span?.end({status:'failed'});throw error;}
    record.error=error.message;record.output=error.output??'';record.exitCode=error.exitCode??null;
-  }
+  } finally {record.timings.executionMs=now()-executionStart;}
   if(plan.scope==='targeted'&&!record.success){
    let empty=/No test files found/i.test(record.output);
    try{empty ||= JSON.parse(readFileSync(reportFile,'utf8')).numTotalTests===0;}catch{}
    if(empty){
     span?.end({status:'failed',scope:'targeted'});
-    const full=await verifyScript(controller,state,script,signal,'full',execute);
+    const full=await verifyScript(controller,state,script,signal,'full',execute,{now});
     full.selectionFallback='Related selection was empty; executed full script instead.';
     state.checks[state.checks.length-1]=full;controller.save(state);return full;
    }
@@ -64,15 +82,17 @@ export async function verifyScript(controller,state,script,signal,mode='auto',ex
  }
  record.after=snapshot(root).fingerprint;record.modifiedFiles=before!==record.after;
  let afterInputs;
- if(inputs)try{afterInputs=captureInputs(root,contract,config.pnpmExecutable,workerEnvironment());}catch{}
+ if(inputs)try{afterInputs=capture();}catch{}
  const stable=inputs&&afterInputs?.key===inputs.key;
  record.reusable=!!(record.success&&stable&&record.scope==='full');
  if(inputs&&!stable){record.reusable=false;record.inputChangedDuringRun=true;if(record.execution==='reused'){record.success=false;record.error='Inputs changed during reuse validation; run verification again.';}}
- record.durationMs=Math.round(performance.now()-started);
+ record.durationMs=Math.round(now()-started);
  if(signal?.aborted){record.success=false;record.reusable=false;record.error='Verification cancelled.';}
  record.inputFingerprint=inputs?.key??null;
  record.coverage=record.scope==='targeted'?'selected-tests-only':'full-script';
  if(record.reusable&&record.execution==='executed')saveReceipt(receiptFile,{schema:1,id,scope:'full',success:true,at:record.at,artifact:before,inputs:afterInputs,tests:record.tests,testCount:record.testCount});
+ if(key&&costsFile)try{observeCosts(costsFile,key,costs,record,beforeTree,contract);}catch{costWarning='Timing history could not be saved; the verification result is unaffected.';}
+ if(costWarning)record.costWarning=costWarning;
  span?.end({status:record.success?'completed':signal?.aborted?'cancelled':'failed',execution:record.execution,scope:record.scope});
  state.checks=[...(state.checks??[]),record].slice(-4);controller.save(state);
  return record;

package/package.json

@@ -1,76 +1,76 @@
-{
-  "name": "@rockysoft/opencode-hybrid-workflow",
-  "version": "0.6.0",
-  "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": "latest"
-  },
-  "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
-    }
-  },
-  "dependencies": {
-    "diff": "9.0.0"
-  }
-}
+{
+  "name": "@rockysoft/opencode-hybrid-workflow",
+  "version": "0.7.0",
+  "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": "latest"
+  },
+  "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
+    }
+  },
+  "dependencies": {
+    "diff": "9.0.0"
+  }
+}