@redue/cli 0.1.0-alpha.3 → 0.1.0-alpha.31

package/src/node-onboarding.mjs

@@ -1,16 +1,26 @@
+import {directProject,directQualification} from './direct-typescript.mjs';
+import {testProject,testRecipeScript,testCheckInputs,testsQualification} from './test-direct.mjs';
+import {generalIssue,scriptCheckInputs,scriptProject,scriptQualification} from './node-script.mjs';
+import {sandboxCheckInputs,sandboxKinds,sandboxQualification} from './sandbox.mjs';
+// Init proposes the general recipe for typecheck and lint scripts; test
+// scripts use the sandboxed recipe first, then the direct test recipe
+// (Vitest, Jest).
+const generalKinds=['typecheck','lint'];
+const perPackageLimit=50;
 import fs from 'node:fs';
 import path from 'node:path';
 import {spawnSync} from 'node:child_process';
-import micromatch from './glob.mjs';
 import {yarnWorkspaceTypecheckInputs} from './yarn-workspace-inputs.mjs';
 import {pnpmInstallInfo,pnpmProjectInfo,pnpmTypecheckInputs} from './pnpm-inputs.mjs';
 import {realObservedPath} from './path-identity.mjs';
 import {findExecutable} from './executable-lookup.mjs';
+import {workspaceManifests} from './workspace-manifests.mjs';
+import {partName,tscRuns} from './typescript-invocation.mjs';
 
 const exists=file=>{try{fs.accessSync(file);return true;}catch{return false;}};
 const readJson=file=>JSON.parse(fs.readFileSync(file,'utf8'));
 const scriptNames={
-  typecheck:['typecheck','type-check','check:types','types:check'],
+  typecheck:['typecheck','type-check','check:types','types:check','check-types','tsc','types','lint:types'],
   test:['test','test:unit','test:check'],
   lint:['lint','lint:check'],
   build:['build'],
@@ -80,7 +90,29 @@ function manager(root,pkg) {
   return {name,version,layout:'node-modules/classic',issue:null,lockfiles:locks};
 }
 const exactTypeScript=script=>script.trim()==='tsc --noEmit';
-function sourceLinkIssue(root) {
+// A script of tsc runs that each pass --noEmit (typescript-invocation.mjs).
+const noEmitRuns=script=>Boolean(tscRuns(script)?.every(run=>run.noEmit));
+// Ready checks for a typecheck, one per tsc run: the script's runs (a chain
+// gives NAME.1 ... NAME.n), or with no script one proposed `tsc --noEmit`.
+// `make(run)` returns a run's command, cwd and inputs, or throws why its
+// contract does not hold.
+function tscChecks(name,script,scripts,make){
+  const runs=script===null?[{args:['--noEmit']}]:tscRuns(scripts[script]);
+  if(!runs)throw Error('the script is not tsc runs in a supported form');
+  return runs.map(({args},i)=>({name:partName(name,i+1,runs.length),
+    ...(script===null?{}:{script}),...make({script,args,count:runs.length})}));
+}
+// A proposed `tsc --noEmit` only where nothing typechecks already: a script
+// that runs any TypeScript checker in another form (tsc -b, vue-tsc,
+// svelte-check, tsgo, also quoted or wrapped by concurrently or run-p) is the
+// project's own typecheck, which plain tsc would not match.
+const typeChecker=/(?:^|[^\w-])(?:tsc|vue-tsc|tsgo|svelte-check|tsc-watch)(?=$|[^\w-])|\bastro check\b|\bnuxi typecheck\b/;
+const typechecks=scripts=>Object.values(scripts||{}).some(text=>typeof text==='string'&&typeChecker.test(text));
+const proposable=(dir,scripts)=>exists(path.join(dir,'tsconfig.json'))&&!typechecks(scripts);
+// The inputs a TypeScript contract adds to its check's config: no exclusions,
+// which would outlive the tsconfig they came from; the plan adds the current ones.
+const contractInputs=contract=>[...contract.configs,...contract.sourcePatterns.filter(p=>!p.startsWith('!'))];
+export function sourceLinkIssue(root) {
   const stack=likelyDirs.filter(name=>exists(path.join(root,name)));
   let inspected=0;
   while(stack.length){
@@ -105,7 +137,8 @@ function sourceInputs(root,kind,lockfiles) {
     '!node_modules/**','!.git/**'])];
   const dirs=likelyDirs.filter(name=>exists(path.join(root,name)))
     .map(name=>`${name}/**`);
-  return [...new Set([...files,...(dirs.length?dirs:['package.json'])])];
+  // A workspace package's node_modules under them is installed, not source.
+  return [...new Set([...files,...(dirs.length?[...dirs,'!**/node_modules/**']:['package.json'])])];
 }
 function classify(kind,scriptName,script,pkg,managerInfo,root) {
   const value=script.trim();
@@ -116,7 +149,7 @@ function classify(kind,scriptName,script,pkg,managerInfo,root) {
     managerInfo.name==='npm'&&
     exists(path.join(root,'tsconfig.json'))&&
     exists(path.join(root,'node_modules/typescript/package.json')))
-    return {level:'ready',reason:'canonical local tsc --noEmit; checked again before reuse',
+    return {level:'recording',reason:'npm launcher uses unobserved remote/cache/time inputs; execution can be recorded, but cannot be reused',
       qualification:'typescript-noemit-v1'};
   if(kind==='typecheck')return {level:'recording',reason:
     'TypeScript invocation, installation, or configuration is outside the automatic noEmit contract'};
@@ -130,36 +163,63 @@ function classify(kind,scriptName,script,pkg,managerInfo,root) {
     'Vite detected; build environment and generated inputs need review':
     'build script detected; generated and runtime inputs need review'};
 }
+// Typecheck scripts named under a typecheck name (`typecheck:test`,
+// `tsc:build`), watch scripts aside.
+const typecheckFamily=/^(?:typecheck|type-check|check-types|check:types|types:check|tsc):(?!.*watch)/;
 function selectScript(kind,names,scripts) {
   const preferred=names.find(name=>typeof scripts[name]==='string'&&
     scripts[name].trim()&&!/^echo\s+["']?Error: no test specified/.test(scripts[name]));
   if(preferred)return {script:preferred};
+  const family=kind==='typecheck'?Object.keys(scripts).filter(name=>typecheckFamily.test(name)&&
+    typeof scripts[name]==='string'&&scripts[name].trim()&&!/(?:^|\s)(?:--watch|-w)(?:\s|$)/.test(scripts[name])):[];
+  if(family.length===1)return {script:family[0]};
   const candidates=Object.keys(scripts).filter(name=>{
     const value=scripts[name]?.trim();
     if(typeof value!=='string')return false;
-    if(kind==='typecheck')return exactTypeScript(value);
+    if(kind==='typecheck')return noEmitRuns(value);
     if(kind==='test')return /^(?:vitest|jest)(?:\s|$)/.test(value);
     if(kind==='lint')return /^eslint(?:\s|$)/.test(value);
     return /^vite\s+build(?:\s|$)/.test(value);
   });
+  // A lone plain `tsc --noEmit` wins over other tsc shapes beside it (a
+  // project's `typescript` next to `typescript:tests:raw`).
+  const exact=kind==='typecheck'?candidates.filter(name=>exactTypeScript(scripts[name])):[];
+  if(exact.length===1)return {script:exact[0]};
   return candidates.length===1?{script:candidates[0]}:
-    candidates.length>1?{ambiguous:candidates}:{};
+    candidates.length>1?{ambiguous:candidates}:family.length>1?{ambiguous:family}:{};
+}
+// A pnpm workspace package's TypeScript run, as its check's command, cwd and inputs.
+function pnpmCheck(root,name,dir,manifest,run){
+  const contract=pnpmTypecheckInputs(root,name,run);
+  if(contract.limitations.length)throw Error(contract.limitations.join('; '));
+  return {cwd:dir,command:['@node',`@typescript-bin:${dir}`,...run.args],
+    inputs:[...new Set(['package.json','pnpm-lock.yaml','pnpm-workspace.yaml',manifest,
+      ...contractInputs(contract)])]};
+}
+// Workspace packages as init finds them, with their scripts; [] without workspaces.
+export function workspacePackages(root){
+  root=realObservedPath(root);
+  const pkg=readJson(path.join(root,'package.json')),pm=manager(root,pkg);
+  const patterns=pm.name==='pnpm'?pm.workspacePatterns:Array.isArray(pkg.workspaces)?pkg.workspaces:pkg.workspaces?.packages;
+  if(!Array.isArray(patterns)||!patterns.length)return [];
+  return workspaceManifests(root,patterns).map(({file,pkg:member})=>
+    ({name:member.name,dir:path.posix.dirname(file),scripts:member.scripts&&typeof member.scripts==='object'?member.scripts:{}}));
 }
-function workspaceManifests(root,patterns) {
-  const listing=spawnSync('git',['ls-files','--cached','--others','--exclude-standard',
-    '-z','--',':(glob)**/package.json'],{cwd:root,encoding:'utf8',timeout:5000,
-    maxBuffer:32*1024*1024,stdio:['ignore','pipe','ignore'],
-    env:{...process.env,GIT_OPTIONAL_LOCKS:'0'}});
-  if(listing.status!==0||listing.error)throw Error('workspace package manifests cannot be inspected');
-  const matched=listing.stdout.split('\0').filter(Boolean).filter(file=>{
-    const dir=path.posix.dirname(file);
-    return dir!=='.'&&!dir.split('/').includes('node_modules')&&
-      micromatch.isMatch(dir,patterns,{dot:true});
-  }).sort();
-  if(matched.length>50)throw Error('more than 50 workspace packages found; select checks explicitly');
-  return matched.map(file=>({file,pkg:readJson(path.join(root,file))}));
+// The general recipe for a root script, or why it does not apply: a
+// supported package manager and platform, and a script (with its pre and post
+// scripts) that, read as text, starts only Node programs.
+function generalCheck(root,kind,script){
+  const issue=generalIssue(root,script);
+  if(issue)throw Error(issue);
+  const project=scriptProject(root,script);
+  return {config:{name:kind,script,kind,qualification:scriptQualification,...scriptCheckInputs(project.dirs)},manager:project.manager};
 }
-export function discoverNodeProject(root) {
+export function discoverNodeProject(root,{recipe=null}={}) {
+  if(recipe&&!['typescript-direct','tests-direct','node-script','sandbox'].includes(recipe))
+    throw Error('unknown recipe; use typescript-direct, tests-direct, node-script or sandbox');
+  // Without --recipe, init tries the strict recipes first, then the general
+  // one, then the sandboxed one.
+  const auto=recipe===null;
   root=realObservedPath(root);
   const packageFile=path.join(root,'package.json');
   if(!exists(packageFile))throw Error('run init from a repository containing package.json');
@@ -176,36 +236,116 @@ export function discoverNodeProject(root) {
     workspacePatterns.some(value=>typeof value!=='string'||path.isAbsolute(value)||
       value.split('/').includes('..'))))
     throw Error('workspace patterns need a supported project-relative package list');
-  const checks=[],ambiguous=[];
+  const checks=[],ambiguous=[],skipped=[];
   for(const [kind,names] of Object.entries(scriptNames)) {
     const selected=selectScript(kind,names,scripts),script=selected.script;
     if(selected.ambiguous)ambiguous.push({kind,scripts:selected.ambiguous});
-    if(!script)continue;
+    // With no typecheck script, a root tsconfig.json gets a proposed
+    // `tsc --noEmit` check; package.json stays unchanged. It is kept only
+    // when a contract makes it ready.
+    const proposed=!script&&!selected.ambiguous&&kind==='typecheck'&&!observationIssue&&
+      proposable(root,scripts);
+    if(!script&&!proposed)continue;
     let classification=observationIssue?{level:'unsupported',reason:observationIssue}:
-      classify(kind,script,scripts[script],pkg,pm,root);
-    if(workspaces&&classification.level==='ready')classification={level:'recording',
+      script?classify(kind,script,scripts[script],pkg,pm,root):{level:'recording',reason:'no typecheck script'};
+    let parts=null;
+    if(workspaces&&classification.qualification==='typescript-noemit-v1')classification={level:'recording',
       reason:'workspace task and installed-input closure need explicit qualification'};
     const check={name:kind,script,kind,inputs:sourceInputs(root,kind,pm.lockfiles||[])};
-    if(pm.name==='pnpm'&&kind==='typecheck'&&!workspaces&&!pm.issue&&
-      /^(?:tsc --noEmit|tsc -p (?:\.|tsconfig\.json)(?: --noEmit)?)$/.test(scripts[script].trim())){
-      try{const contract=pnpmTypecheckInputs(root,'.',script);
-        if(contract.limitations.length)throw Error(contract.limitations.join('; '));
-        check.command=['@node','@typescript-bin:.',
-          ...scripts[script].trim().split(/\s+/).slice(1)];
-        check.cwd='.';
-        check.inputs=['package.json','pnpm-lock.yaml',
-          ...(exists(path.join(root,'pnpm-workspace.yaml'))?['pnpm-workspace.yaml']:[]),
-          'tsconfig.json','src/**'];
-        classification={level:'ready',reason:'pinned pnpm TypeScript inputs and installation; checked again before reuse',
+    if((recipe==='typescript-direct'||auto&&pm.name==='npm'&&!workspaces)&&kind==='typecheck'){
+      try{
+        if(pm.name!=='npm'||workspaces||observationIssue||pm.issue)throw Error('direct recipe requires a supported single-package npm checkout');
+        let version;
+        parts=tscChecks('typecheck',script??null,scripts,run=>{
+          version=directProject(root,run).version;
+          return {command:['@node','@typescript-compiler:.',...run.args],cwd:'.'};});
+        classification={level:'ready',qualification:directQualification,
+          reason:`explicit local TypeScript ${version} compilation; npm launcher/lifecycle scripts are not executed; package.json stays unchanged`};
+      }catch(e){classification={level:'recording',reason:`Direct recipe unavailable (${e.code||e.message}); original npm script retained, without bypassing required behavior`};}
+    }
+    if((recipe==='tests-direct'||auto)&&kind==='test'){
+      try{
+        if(!['npm','pnpm','yarn'].includes(pm.name)||workspaces||observationIssue||pm.issue)
+          throw Error('test recipe requires a supported single-package npm, pnpm or Yarn checkout');
+        const chosen=testRecipeScript(scripts);
+        if(chosen.ambiguous)throw Error(`several scripts run Vitest or Jest directly (${chosen.ambiguous.join(', ')})`);
+        if(!chosen.script)throw Error(chosen.issue||'no script runs Vitest or Jest directly');
+        const project=testProject(root,chosen.script);
+        Object.assign(check,{script:chosen.script,command:['@node',`@test-runner:${project.runner}`,...project.args],cwd:'.',
+          ...testCheckInputs(project)});
+        classification={level:'ready',qualification:testsQualification,
+          reason:`explicit local ${project.runner} ${project.version} run of script ${JSON.stringify(chosen.script)}; the whole checkout is its input; npm and lifecycle scripts are not executed`};
+      }catch(e){classification={level:'recording',reason:`Test recipe unavailable (${e.code||e.message}); original npm script retained`};}
+    }
+    if(recipe!=='node-script'&&recipe!=='sandbox'&&pm.name==='pnpm'&&kind==='typecheck'&&!workspaces&&!pm.issue&&(script===undefined||tscRuns(scripts[script]))){
+      try{
+        parts=tscChecks('typecheck',script??null,scripts,run=>{
+          const contract=pnpmTypecheckInputs(root,'.',run);
+          if(contract.limitations.length)throw Error(contract.limitations.join('; '));
+          return {command:['@node','@typescript-bin:.',...run.args],cwd:'.',
+            inputs:[...new Set(['package.json','pnpm-lock.yaml',
+              ...(exists(path.join(root,'pnpm-workspace.yaml'))?['pnpm-workspace.yaml']:[]),
+              ...contractInputs(contract)])]};});
+        classification={level:'ready',reason:'pnpm TypeScript inputs and installation; checked again before reuse',
           qualification:'pnpm-tsc-v1'};}
       catch(e){classification={level:'recording',reason:`pnpm TypeScript contract needs review: ${e.message}`};}
     }
+    // The general recipe's row, when it takes the script.
+    let generalIssue=null,generalRow=null;
+    if((auto||recipe==='node-script')&&script&&generalKinds.includes(kind)&&classification.level!=='ready'&&!observationIssue){
+      try{
+        const general=generalCheck(root,kind,script);
+        generalRow={config:general.config,level:'ready',qualification:scriptQualification,
+          reason:`general recipe: ${general.manager} runs script ${JSON.stringify(script)} with REDUE's recorder in every Node process; the whole checkout is its input`};
+      }catch(e){generalIssue=e.message;classification={...classification,reason:`General recipe unavailable (${e.message}); ${classification.reason}`};}
+    }
+    // After the strict recipes, a root typecheck or lint script gets the
+    // sandboxed recipe, which also covers programs the general recipe cannot
+    // record. It is ready only once init has run it both ways (bin/redue.mjs);
+    // `fallback` is the row init writes when that shows a difference or the
+    // sandbox cannot run here: the general recipe's, when it takes the script,
+    // or the direct test recipe's.
+    // Where the sandbox cannot start at run time, a script the general recipe
+    // takes is recorded as it would record it (cli.mjs).
+    // A script whose program is not installed gets none, and neither does one
+    // that changes files (`--fix`, `--write`): init would run it twice.
+    const writes=script&&['pre'+script,script,'post'+script].map(name=>scripts[name]).find(text=>typeof text==='string'&&
+      /(?:^|\s)--(?:fix|write|unsafe-fixes)(?=[\s=]|$)/.test(text));
+    if(writes)classification={...classification,reason:`Sandboxed recipe unavailable (the script changes files: ${writes.match(/--(?:fix|write|unsafe-fixes)/)[0]}); ${classification.reason}`};
+    // A test script gets it before the direct test recipe, which is then its
+    // fallback, when both run the same script: in the census the direct
+    // recipe's results went STALE when the build changed its output, and the
+    // sandboxed ones stayed CURRENT.
+    if((auto||recipe==='sandbox')&&script&&sandboxKinds.includes(kind)&&!observationIssue&&
+      (classification.level!=='ready'||auto&&kind==='test'&&check.script===script)&&
+      !/REDUE cannot find/.test(generalIssue||'')&&!writes){
+      try{
+        const project=scriptProject(root,script);
+        const fallback=generalRow??{config:{...check,...classification.qualification?{qualification:classification.qualification}:{}},...classification};
+        checks.push({config:{name:kind,script,kind,qualification:sandboxQualification,...sandboxCheckInputs(project.dirs)},level:'ready',
+          qualification:sandboxQualification,fallback,
+          reason:`sandboxed recipe: ${project.manager} runs script ${JSON.stringify(script)} inside the OS sandbox${generalIssue?` (the general recipe cannot record it: ${generalIssue})`:
+            generalRow?'; where the sandbox cannot run, the general recipe records it':''}; the whole checkout is its input`});
+        continue;
+      }catch(e){classification={...classification,reason:`Sandboxed recipe unavailable (${e.code?.replace(/^test-/,'')||e.message}); ${classification.reason}`};}
+    }
+    if(generalRow){checks.push(generalRow);continue;}
+    // A proposed `tsc --noEmit` that no recipe takes is left out, with why.
+    if(!script&&classification.level!=='ready'){
+      skipped.push({kind,reason:`${kind}: no typecheck script, and a proposed tsc --noEmit was not taken (${classification.reason})`});continue;}
+    if(parts&&classification.level==='ready'){
+      for(const part of parts)checks.push({config:{...check,...part,qualification:classification.qualification},...classification});
+      continue;
+    }
     if(classification.qualification)check.qualification=classification.qualification;
     checks.push({config:check,...classification});
   }
   if(workspaces&&!observationIssue){
-    const seen=new Set();
-    for(const {file,pkg:member} of workspaceManifests(root,workspacePatterns)){
+    const seen=new Set(),members=workspaceManifests(root,workspacePatterns);
+    // Past 50 packages, init proposes the root's checks only and says so.
+    if(members.length>perPackageLimit)skipped.push({kind:'workspace',packages:members.length,
+      reason:`${members.length} workspace packages, more than ${perPackageLimit}: per-package checks were not proposed; add the ones you need to the config`});
+    for(const {file,pkg:member} of members.length>perPackageLimit?[]:members){
       const dir=path.posix.dirname(file),name=member.name;
       if(typeof name!=='string'||!name||seen.has(name)){
         ambiguous.push({kind:'workspace',scripts:[dir],reason:'missing or duplicate package name'});
@@ -217,6 +357,16 @@ export function discoverNodeProject(root) {
         const selected=selectScript(kind,names,member.scripts||{});
         if(selected.ambiguous){ambiguous.push({kind:`${name}:${kind}`,
           scripts:selected.ambiguous});continue;}
+        // A pnpm package with a tsconfig.json and no typecheck script gets a
+        // proposed `tsc --noEmit` check when the pnpm contract holds.
+        if(!selected.script&&kind==='typecheck'&&pm.name==='pnpm'&&!pm.issue&&
+          proposable(path.join(root,dir),member.scripts)&&!typechecks(scripts)){
+          try{for(const part of tscChecks(`${name}:typecheck`,null,{},run=>pnpmCheck(root,name,dir,file,run)))
+            checks.push({config:{kind,workspace:name,qualification:'pnpm-tsc-v1',...part},level:'ready',
+              reason:'proposed tsc --noEmit for the package\'s tsconfig.json; pnpm workspace TypeScript inputs; checked again before reuse'});}
+          catch{}
+          continue;
+        }
         if(!selected.script)continue;
         const command=pm.name==='npm'?['@which:npm','run',selected.script,
           '--workspace',name]:pm.name==='yarn'?
@@ -224,7 +374,7 @@ export function discoverNodeProject(root) {
           ['@which:pnpm','--filter',name,'run',selected.script];
         const check={name:`${name}:${kind}`,kind,command,
           inputs:['package.json',...(pm.lockfiles||[]),`${dir}/**`,
-            `!${dir}/node_modules/**`]};
+            `!${dir}/node_modules/**`,`!${dir}/**/node_modules/**`]};
         let level=pm.issue&&pm.name!=='pnpm'?'unsupported':'recording';
         let reason=pm.issue||'workspace script found; shared configuration and installed inputs need review';
         if(!pm.issue&&pm.name==='yarn'&&pm.layout==='node-modules/classic'&&
@@ -237,27 +387,26 @@ export function discoverNodeProject(root) {
             level='ready';reason='pinned Yarn workspace tsc and installed inputs; checked again before reuse';
           }catch(e){reason=`workspace TypeScript contract needs review: ${e.message}`;}
         }
-        if(!pm.issue&&pm.name==='pnpm'&&kind==='typecheck'&&
-          /^(?:tsc --noEmit|tsc -p (?:\.|tsconfig\.json)(?: --noEmit)?)$/.test(
-            (member.scripts||{})[selected.script]?.trim()||'')&&
-          !member.scripts?.['pre'+selected.script]&&!member.scripts?.['post'+selected.script]){
-          try{const contract=pnpmTypecheckInputs(root,name,selected.script);
-            if(contract.limitations.length)throw Error(contract.limitations.join('; '));
-            check.workspace=name;check.qualification='pnpm-tsc-v1';
-            check.script=selected.script;
-            check.cwd=dir;
-            check.command=['@node',`@typescript-bin:${dir}`,
-              ...member.scripts[selected.script].trim().split(/\s+/).slice(1)];
-            check.inputs=['package.json','pnpm-lock.yaml','pnpm-workspace.yaml',file,
-              `${dir}/src/**`];
-            level='ready';reason='pinned pnpm workspace TypeScript inputs; checked again before reuse';
+        if(!pm.issue&&pm.name==='pnpm'&&kind==='typecheck'&&tscRuns((member.scripts||{})[selected.script])){
+          try{const parts=tscChecks(`${name}:typecheck`,selected.script,member.scripts,run=>pnpmCheck(root,name,dir,file,run));
+            for(const part of parts)checks.push({config:{kind,workspace:name,qualification:'pnpm-tsc-v1',...part},level:'ready',
+              reason:'pnpm workspace TypeScript inputs; checked again before reuse'});
+            continue;
           }catch(e){reason=`pnpm TypeScript contract needs review: ${e.message}`;}
         }
+        if(recipe==='tests-direct'&&kind==='test'&&!pm.issue){
+          try{const project=testProject(root,selected.script,dir);
+            Object.assign(check,{workspace:name,script:selected.script,cwd:dir,
+              command:['@node',`@test-runner:${project.runner}`,...project.args],...testCheckInputs(project),
+              qualification:testsQualification});
+            level='ready';reason=`explicit local ${project.runner} ${project.version} run of ${name}'s script ${JSON.stringify(selected.script)}; the whole checkout is its input; the package manager and lifecycle scripts are not executed`;
+          }catch(e){reason=`Test recipe unavailable (${e.code||e.message}); original script retained`;}
+        }
         checks.push({config:check,level,reason});
       }
     }
   }
   return {schema:1,root,manager:pm,observationIssue,workspaces,node:process.version,
-    checks,ambiguous,
+    checks,ambiguous,skipped,
     config:{schema:1,packageManager:pm.name||'unknown',checks:checks.map(row=>row.config)}};
 }