openmerit 0.1.6-preview.4 → 0.1.6

package/dist/terminal/public/styles.css

@@ -797,3 +797,21 @@ body.keyboard .complete-map .map-node rect,body.keyboard .complete-map .map-edge
 .reference-pagination { display: flex; justify-content: flex-end; align-items: center; gap: 20px; margin-top: 14px; }
 .reference-pagination > :first-child { margin-right: auto; }
 .reference-pagination button:disabled { opacity: .35; cursor: default; }
+
+/* Background discovery is useful progress, not a blocking splash screen. */
+.index-progress { display:grid;grid-template-columns:minmax(240px,1fr) minmax(120px,240px) auto;align-items:center;gap:12px 24px;padding:18px 0;margin-bottom:24px;border-bottom:1px solid var(--line); }
+.index-progress-copy { display:flex;flex-wrap:wrap;align-items:baseline;gap:8px 16px; }
+.index-progress strong { font-size:13px;font-weight:500; }
+.index-progress-copy span,.index-progress small { font-size:12px;color:var(--muted); }
+.index-progress small { grid-column:1 / -1; }
+.index-progress progress,.terminal-loading progress { appearance:none;display:block;height:2px;border:0;background:#303030;border-radius:2px;width:100%;overflow:hidden; }
+.index-progress progress::-webkit-progress-bar,.terminal-loading progress::-webkit-progress-bar { background:#303030; }
+.index-progress progress::-webkit-progress-value,.terminal-loading progress::-webkit-progress-value { background:#b6b6b6; }
+.index-progress progress::-moz-progress-bar,.terminal-loading progress::-moz-progress-bar { background:#b6b6b6; }
+progress:indeterminate { opacity:.55; }
+.terminal-loading { padding:64px 0;max-width:600px; }
+.terminal-loading h1 { font-size:26px;letter-spacing:-.035em;font-weight:500;margin:0 0 14px; }
+.terminal-loading p { color:var(--muted);font-size:14px;line-height:1.6;margin-bottom:28px; }
+.terminal-loading progress { max-width:260px;margin-bottom:16px; }
+.terminal-loading>span { color:var(--muted);font-size:12px; }
+@media(max-width:700px) { .index-progress { grid-template-columns:1fr auto;gap:14px; }.index-progress progress { grid-column:1 / -1;grid-row:2; }.index-progress small { line-height:1.5; } }

package/dist/terminal/src/cli.mjs

@@ -5,7 +5,6 @@ import { startTerminal } from './server.mjs';
 import { createCollector, loadConfig } from './collect.mjs';
 import { sampleSnapshot } from './sample.mjs';
 import { openBrowser } from './browser.mjs';
-import { indexDiagnostics, indexRepository } from './repository-index.mjs';
 
 const help = `OpenMerit · Inference Terminal
 
@@ -50,7 +49,7 @@ async function main() {
   if (!(await stat(root)).isDirectory()) throw new Error('Choose a project directory.');
   const config = demo ? null : await loadConfig(root);
   if (config && !discovery) config.discovery = false;
-  if (diagnostics) { const index = !demo && config.discovery ? await indexRepository(root) : null; console.log(JSON.stringify(indexDiagnostics(index), null, 2)); return; }
+  if (diagnostics) { const {indexRepository,indexDiagnostics}=await import('./repository-index.mjs'); const index = !demo && config.discovery ? await indexRepository(root) : null; console.log(JSON.stringify(indexDiagnostics(index), null, 2)); return; }
   if (json) { console.log(JSON.stringify(demo ? sampleSnapshot() : await createCollector(root, config, interval)(), null, 2)); return; }
   const terminal = await startTerminal({ root, port, interval, demo, config, fallbackPort: !explicitPort });
   console.log(`\n  OpenMerit · Inference Terminal\n\n  ${terminal.url}\n\n  ${demo ? 'Sample environment · fictional data' : 'Current project · passive collection'}\n  Updates every ${interval}s. Press Ctrl+C to close.\n`);

package/dist/terminal/src/collect.mjs

@@ -3,7 +3,7 @@ import { basename, isAbsolute, relative, resolve, sep } from 'node:path';
 import os from 'node:os';
 import { historyExtent } from './history.mjs';
 import { discoverProject, discoveryCandidates } from './discovery.mjs';
-import { indexRepository } from './repository-index.mjs';
+import { createBackgroundIndex } from './repository-background.mjs';
 import { createProjectActivity } from './project-activity.mjs';
 import { reconcileActivity } from './activity-merge.mjs';
 import { modelCreators } from './services.mjs';
@@ -230,7 +230,9 @@ async function ollamaSnapshot(endpoint, sourceId = 'ollama', provider = 'Ollama'
 
 function cpuTotals() { return os.cpus().reduce((all, cpu) => ({ idle: all.idle + cpu.times.idle, total: all.total + Object.values(cpu.times).reduce((a, b) => a + b, 0) }), { idle: 0, total: 0 }); }
 
-export function createCollector(root, config, interval = 15) {
+export function createCollector(root, config, interval = 15, { backgroundIndex = false, indexOptions } = {}) {
+  const background=config.discovery&&backgroundIndex?createBackgroundIndex(root,indexOptions):null;
+  let scanner=null;
   const activityReader = new JsonlReader(root, resolve(root, config.activityFile));
   const auditReader = new JsonlReader(root, resolve(root, '.openmerit/events.jsonl'));
   let previousCpu = null;
@@ -239,9 +241,14 @@ export function createCollector(root, config, interval = 15) {
   const projectActivity = createProjectActivity(root, normalizeRecord, { exclude: [resolve(root, config.activityFile)] });
   let projectDiscovery = { sources: [], inventory: [], runtimes: [] }, repository = null, discoveredAt = 0;
   const knownRuntimes = new Map();
-  return async function collect() {
+  const collect = async function collect() {
     const scan = Boolean(config.discovery) && Date.now() - discoveredAt >= 60_000;
-    if (scan) { [projectDiscovery, repository] = await Promise.all([discoverProject(root), indexRepository(root)]); discoveredAt = Date.now(); }
+    background?.start();
+    if (scan) {
+      if(!background)scanner??=(await import('./repository-index.mjs')).createRepositoryScanner(root);
+      [projectDiscovery,repository]=await Promise.all([discoverProject(root),background?null:scanner()]);
+      discoveredAt=Date.now();
+    }
     const allCandidates = config.discovery ? discoveryCandidates(projectDiscovery, config.runtimes, config.ollama, Infinity).filter(runtime => !(config.ollamaDisabled && runtime.type === 'ollama')) : [];
     const candidates = allCandidates.slice(0, 8);
     const discoveryLimits = collectionLimits({ endpoints: allCandidates }, { endpoints: 8 });
@@ -280,12 +287,6 @@ export function createCollector(root, config, interval = 15) {
       const key = `${item.provider}:${item.model}`;
       if (!models.has(key)) models.set(key, { id: key, name: item.model, provider: item.provider, location: item.location, state: 'observed', sourceId: item.sourceId, memoryBytes: null });
     }
-    for (const item of repository?.models ?? []) {
-      const key = `${item.provider}:${item.name}`;
-      const existing = models.get(key);
-      if (!existing) models.set(key, item);
-      else existing.declarationIds = [...new Set([...(existing.declarationIds ?? []), ...item.declarationIds])];
-    }
     const cpu = cpuTotals();
     const cpuPercent = previousCpu && cpu.total > previousCpu.total ? Math.max(0, Math.min(100, 100 * (1 - (cpu.idle - previousCpu.idle) / (cpu.total - previousCpu.total)))) : null;
     previousCpu = cpu;
@@ -301,7 +302,7 @@ export function createCollector(root, config, interval = 15) {
     ];
     if (config.discovery) {
       sources.push(...projectDiscovery.sources);
-      if (repository) sources.push({ id: 'repository', name: 'Repository index', kind: 'Code & configuration', state: repository.summary.truncated || repository.issues.length ? 'partial' : 'connected', detail: `${repository.summary.filesRead} files · ${repository.references.length} declarations`, updatedAt: repository.checkedAt, coverage: ['Endpoint declarations', 'Model references', 'Call sites', 'Coverage gaps'], access: 'Selected project', note: 'Static syntax only. Source code is never executed. Declarations do not establish usage, reachability, loaded models, or physical hosts. Examples, candidates, benchmarks and fallbacks are separated. Paths and line numbers identify the evidence; prompts, credentials and raw source contents are discarded.' });
+
       sources.push(...logs.sources);
       if (discoveryLimits.length) sources.push({ id: 'runtime-discovery', name: 'Endpoint discovery coverage', kind: 'Project discovery', state: 'partial', truncated: true, limits: discoveryLimits, detail: '.env · .env.local', note: limitNote(discoveryLimits).trim() });
     }
@@ -330,19 +331,40 @@ export function createCollector(root, config, interval = 15) {
     const residentModels = residentRuntimes.flatMap(runtime => runtime.models).filter(model => model.state === 'loaded');
     const machine = { id: 'this-machine', projectLinked: localComputeLinked, scope: 'whole-machine', name: os.hostname(), nameField: 'hostname', hostname: os.hostname(), site: '', rack: '', sourceId: 'machine', observedAt: now, chip: text(os.cpus()[0]?.model, os.arch()), cores: os.cpus().length, platform: os.platform(), arch: os.arch(), memoryTotal, memoryUsed, cpuPercent, history: [...hardwareHistory], accelerators: [], residencyReported: residentRuntimes.length > 0, loadedModels: residentModels.map(model => ({ ...model, runtime: model.provider, memoryKind: 'accelerator', deploymentId: `runtime:${model.id}` })) };
     const hosts = [...(localComputeLinked ? [machine] : []), ...retainHostHistory(hardware.hosts, hostHistories)];
-    const inventory = [...config.inventory.filter(item => item.kind !== 'model'), ...projectDiscovery.inventory, ...(repository?.inventory ?? [])].map(item => ({ ...item, sourceId: item.sourceId || 'inventory' }));
+    const inventory = [...config.inventory.filter(item => item.kind !== 'model'), ...projectDiscovery.inventory].map(item => ({ ...item, sourceId: item.sourceId || 'inventory' }));
     const creatorReports = [...records, ...(config.deployments ?? []), ...config.inventory.filter(item => item.kind === 'model').map(item => ({ ...item, sourceId: 'inventory' })), ...hardware.hosts.flatMap(host => host.loadedModels.map(model => ({ ...model, sourceId: 'hardware' })))];
     const historySources = sources.filter(source => source.id === 'activity' || source.id.startsWith('project-log:') || source.id === 'project-log-coverage');
     const gaps = historySources.filter(source => source.state === 'partial' || source.state === 'unavailable' || source.truncated || source.invalid);
     const history = { ...historyExtent(records, now), retained: records.length, coverage: gaps.length || reconciliation.excluded ? 'partial' : 'available', sourceIds: historySources.filter(source => source.state !== 'not_found').map(source => source.id) };
-    return {
+    const snapshot = {
       schemaVersion: 1, mode: 'live', observedAt: now, interval, history,
-      repository: repository ? { references: repository.references, issues: repository.issues, summary: repository.summary, checkedAt: repository.checkedAt } : null,
+      repository: null,
       discovery: { enabled: Boolean(config.discovery), checkedAt: discoveredAt ? new Date(discoveredAt).toISOString() : null, intervalSeconds: 60, runtimeCandidates: candidates.length, requestSource: requestSources.length > 1 ? 'combined' : requestSources[0] ?? null, requestSources, reconciliation: { duplicates: reconciliation.duplicates, excluded: reconciliation.excluded, conflicts: reconciliation.conflicts, sources: reconciliation.sources } },
       project: { name: basename(root), scope: 'Current project' },
       models: modelCreators([...models.values()], creatorReports), inventory: [...inventory, ...(config.runtimes ?? []).map(runtime => ({ name: runtime.name, kind: runtime.type === 'openai-compatible' ? 'unknown' : 'runtime', location: runtimePlacement(runtime).location, state: 'configured' }))],
       records, taskSummaries, sources, deployments, capacityPools, runtimeStats: runtimes.map(runtime => runtime.stats).filter(Boolean),
       machine, hosts,
     };
+    return background?snapshot:withRepository(snapshot,repository);
   };
+  let previousBase=null,previousIndex=null,composed=null;
+  collect.current=snapshot=>{
+    if(!background||snapshot.loading)return snapshot;
+    const index=background.get();
+    if(snapshot!==previousBase||index!==previousIndex){composed=withRepository(snapshot,index);previousBase=snapshot;previousIndex=index;}
+    return composed;
+  };
+  collect.close=()=>background?.close();
+  return collect;
+}
+function withRepository(snapshot,repository) {
+  if(!repository)return snapshot;
+  const models=new Map(snapshot.models.map(item=>[`${item.provider}:${item.name}`,item]));
+  for(const item of repository.models){
+    const key=`${item.provider}:${item.name}`,existing=models.get(key);
+    models.set(key,existing?{...existing,declarationIds:[...new Set([...(existing.declarationIds??[]),...item.declarationIds])]}:item);
+  }
+  const phase=repository.progress?.phase,active=phase&&phase!=='complete';
+  const source={id:'repository',name:'Repository index',kind:'Code & configuration',state:active||repository.summary.unresolved||repository.summary.skipped.unreadable||repository.summary.skipped.oversized?'partial':'connected',detail:`${repository.summary.filesIndexed} files · ${repository.references.length} declarations${active?' · '+(phase==='failed'?'index interrupted':'indexing'):''}`,updatedAt:repository.checkedAt,coverage:['Endpoint declarations','Model references','Call sites','Coverage gaps'],access:'Selected project',note:'Static syntax only. Source code is never executed. Declarations do not establish usage, reachability, loaded models, or physical hosts. Examples, candidates, benchmarks and fallbacks are separated. Paths and line numbers identify the evidence; prompts, credentials and raw source contents are discarded.'};
+  return {...snapshot,models:[...models.values()],inventory:[...snapshot.inventory,...repository.inventory],sources:[...snapshot.sources,source],repository:{references:repository.references,issues:repository.issues,summary:repository.summary,checkedAt:repository.checkedAt,revision:repository.revision,progress:repository.progress}};
 }

package/dist/terminal/src/repository-background.mjs

@@ -0,0 +1,37 @@
+import { randomUUID } from 'node:crypto';
+import { Worker } from 'node:worker_threads';
+import { emptyIndexSummary } from './repository-policy.mjs';
+
+// The HTTP server never parses project code. A failed worker leaves the last
+// usable index visible, explicitly marked incomplete, and retries next cycle.
+export function createBackgroundIndex(root,{intervalMs=60_000,limits}={}) {
+  let worker=null,timer=null,closed=false,started=false,revision=0;
+  const session=randomUUID(),nextRevision=()=>`${session}:${++revision}`;
+  let current={references:[],issues:[],models:[],inventory:[],summary:emptyIndexSummary(),checkedAt:null,revision:`${session}:0`,progress:{phase:'queued',processed:0,total:null,discovered:0,parsed:0,reused:0,elapsedMs:0}};
+  const schedule=()=>{if(!closed){clearTimeout(timer);timer=setTimeout(run,intervalMs);timer.unref();}};
+  const failed=()=>{if(closed)return;current={...current,revision:nextRevision(),progress:{...current.progress,phase:'failed'}};schedule();};
+  function run() {
+    if(closed)return;
+    if(!worker) {
+      worker=new Worker(new URL('./repository-worker.mjs',import.meta.url),{workerData:{root,limits},resourceLimits:{maxOldGenerationSizeMb:256},execArgv:process.execArgv.filter(arg=>!arg.startsWith('--input-type'))});
+      worker.on('message',message=>{
+        if(closed)return;
+        if(message.type==='failed'){failed();return;}
+        if(message.type==='complete') {
+          current={...message.index,revision:nextRevision()};schedule();
+        }else {
+          current=message.index?{...message.index,revision:nextRevision()}:{...current,progress:message.progress};
+        }
+      });
+      worker.on('error',()=>{ /* Exit handles termination and the retry. */ });
+      worker.on('exit',()=>{worker=null;failed();});
+      worker.unref();
+    }
+    worker.postMessage('scan');
+  }
+  return {
+    start(){if(!started&&!closed){started=true;run();}},
+    get(){return current;},
+    async close(){closed=true;clearTimeout(timer);const active=worker;worker=null;if(active)await active.terminate();},
+  };
+}

package/dist/terminal/src/repository-index.mjs

@@ -1,17 +1,19 @@
-import { opendir, lstat, open, realpath } from 'node:fs/promises';
+import { opendir, open, realpath } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { join, relative, dirname, extname, sep } from 'node:path';
 import { createHash } from 'node:crypto';
 import { isIP } from 'node:net';
 import { parseCode, parseConfig } from './repository-syntax.mjs';
 import { endpointService } from './service-registry.mjs';
+import { setImmediate as yieldThread } from 'node:timers/promises';
+import { INDEX_LIMITS, emptyIndexSummary } from './repository-policy.mjs';
+export { INDEX_LIMITS } from './repository-policy.mjs';
 
-export const INDEX_LIMITS = Object.freeze({ files:400, entries:8000, bytes:4*1024*1024, fileBytes:128*1024, depth:8, declarations:2000, issues:100 });
 const excluded = new Set(['node_modules','vendor','dist','build','out','coverage','target','venv','env','__pycache__','site-packages','logs','runs','results']);
 const extensions = new Set(['.py','.js','.jsx','.ts','.tsx','.mjs','.cjs','.json','.yaml','.yml','.toml']);
 const privateFile = /(?:^|[._-])(?:credentials?|secrets?|tokens?|passwords?|auth)(?:[._-]|$)|(?:^|\/)id_(?:rsa|ed25519)/i;
 const digest = value=>createHash('sha256').update(value).digest('hex').slice(0,24);
-const safeName = value=>typeof value==='string' && value.length<=160 && !/[\x00-\x1f\x7f]/.test(value) && !/(?:sk[-_]|Bearer\s|(?:api[_-]?key|token|secret|password)\s*[:=])/i.test(value);
+const safeName = value=>typeof value==='string' && value.length<=160 && !/[\x00-\x1f\x7f]/.test(value) && !/(?:\bsk[-_]|Bearer\s|(?:api[_-]?key|token|secret|password)\s*[:=])/i.test(value);
 const modelValue = value=>safeName(value) && /^[A-Za-z0-9][A-Za-z0-9._:/+@-]*$/.test(value) && !value.includes('://');
 const contextFor = file=> /(?:^|\/)(?:benchmarks?|evals?|backtests?)(?:\/|[._-])|(?:benchmark|backtest)/i.test(file)?'benchmark':/(?:^|\/)(?:tests?|fixtures?)(?:\/|[._-])|[._](?:test|spec)\./i.test(file)?'test':/(?:^|\/)(?:examples?|samples?)(?:\/|[._-])|(?:^|\/)\.env\.(?:example|sample|template)/i.test(file)?'example':'application';
 const envFile = file=>/(?:^|\/)\.env(?:\.[\w.-]+)?$/.test(file);
@@ -39,70 +41,158 @@ export function endpointIdentity(value) {
 export function indexDiagnostics(index) {
   // Sharing is opt-in by copying this output. Deliberately exclude paths,
   // names, URLs, values, environment variables and source contents.
-  const counts={};for(const issue of index?.issues??[])counts[issue.code]=(counts[issue.code]||0)+1;
+  const counts=index?.summary?.issueCounts??{};
   return {schemaVersion:1,scope:'repository-index',enabled:Boolean(index),summary:index?.summary??null,issueCounts:counts,limits:INDEX_LIMITS};
 }
-export async function indexRepository(root, limits=INDEX_LIMITS) {
-  const canonical=await realpath(root), files=[], issues=[], parsed=[], references=[];
-  const summary={filesRead:0,bytesRead:0,entriesVisited:0,filesByFormat:{},skipped:{policy:0,unsupported:0,symlink:0,oversized:0,unreadable:0},truncated:false,declarations:0,unresolved:0};
-  const issueKeys=new Set();
-  const issue=(code,file,line=1,field)=>{const key=JSON.stringify([code,file,line,field]);if(issueKeys.has(key))return;issueKeys.add(key);summary.unresolved++;if(issues.length<limits.issues)issues.push({code,...(file?{file}:{}),line,...(field&&safeName(field)?{field}: {})});};
-  async function scan(dir,depth) {
-    let directory;
-    try {directory=await opendir(dir);for await(const entry of directory){
-      if(++summary.entriesVisited>limits.entries){summary.truncated=true;break;}
-      if(entry.isSymbolicLink()){summary.skipped.symlink++;continue;}
-      const isEnv=/^\.env(?:\.[\w.-]+)?$/.test(entry.name);
-      if(entry.name.startsWith('.')&&!isEnv||excluded.has(entry.name)||privateFile.test(entry.name)||/(?:package-lock|pnpm-lock|yarn\.lock|\.min\.|\.d\.ts$)/.test(entry.name)){summary.skipped.policy++;continue;}
-      const path=join(dir,entry.name);
-      if(entry.isDirectory()){
-        if(depth>=limits.depth){summary.truncated=true;continue;}
-        const st=await lstat(path);if(st.isSymbolicLink()||await realpath(path)!==path){summary.skipped.symlink++;continue;}
-        await scan(path,depth+1);
-      }else if(entry.isFile()){
-        if(isEnv||extensions.has(extname(entry.name)))files.push(path);else summary.skipped.unsupported++;
-      }
-      if(summary.entriesVisited>=limits.entries){summary.truncated=true;break;}
-    }}catch{summary.skipped.unreadable++;issue('unreadable-directory',relative(canonical,dir)||'.');}
-  }
-  await scan(canonical,0);
-  // Deterministic selection prefers environment/configuration before source.
-  files.sort((a,b)=>Number(!envFile(a))-Number(!envFile(b))||a.localeCompare(b));
-  if(files.length>limits.files)summary.truncated=true;
-  for(const path of files.slice(0,limits.files)) {
-    const file=relative(canonical,path);let handle;
-    try{
-      if(await realpath(path)!==path || !path.startsWith(canonical+sep)){summary.skipped.symlink++;continue;}
-      handle=await open(path,constants.O_RDONLY|(constants.O_NOFOLLOW||0)|(constants.O_NONBLOCK||0));const stat=await handle.stat();
-      if(!stat.isFile()){summary.skipped.policy++;continue;}
-      if(stat.size>limits.fileBytes){summary.skipped.oversized++;issue('oversized-file',file);continue;}
-      if(summary.bytesRead+stat.size>limits.bytes){summary.truncated=true;continue;}
-      const buffer=Buffer.alloc(Math.min(limits.fileBytes+1,stat.size+1)),{bytesRead}=await handle.read(buffer,0,buffer.length,0);
-      if(bytesRead>limits.fileBytes){summary.skipped.oversized++;issue('oversized-file',file);continue;}
-      summary.filesRead++;summary.bytesRead+=bytesRead;
-      const body=buffer.subarray(0,bytesRead).toString('utf8');
-      if(body.includes('\0')){issue('binary-file',file);continue;}
-      const code=/\.(?:py|[cm]?js|jsx|tsx?)$/.test(file),format=envFile(file)?'dotenv':extname(file).slice(1);
-      summary.filesByFormat[format]=(summary.filesByFormat[format]||0)+1;
-      const result=code?parseCode(body,file):parseConfig(body,file);
-      for(const i of result.issues)issue(i.code,file,i.line,i.field);
-      // Parser input is released after each file; only narrow metadata survives.
-      parsed.push({file,context:contextFor(file),entries:result.entries});
-    }catch{summary.skipped.unreadable++;issue('unreadable-file',file);}
-    finally{await handle?.close();}
+// Cache only parser metadata, never source text, and never write into the project.
+// Endpoint values are sanitized before entering this process-local cache.
+function cacheEntry(entry) {
+  const result={...entry};
+  if (entry.endpoints) result.endpoints=entry.endpoints.map(cacheEntry);
+  if (typeof entry.value==='string' && (entry.kind==='endpoint' || /^https?:\/\//i.test(entry.value))) {
+    result.endpointValue=endpointIdentity(entry.value) || {invalid:true};
+    result.value=result.endpointValue.address || '';
   }
+  return result;
+}
+function reporter(summary, issues, limit) {
+  const seen=new Set();
+  return (code,file,line=1,field)=>{
+    const key=JSON.stringify([code,file,line,field]);if(seen.has(key))return;seen.add(key);
+    summary.unresolved++;summary.issueCounts[code]=(summary.issueCounts[code]||0)+1;
+    if(issues.length<limit)issues.push({code,...(file?{file}:{}),line,...(field&&safeName(field)?{field}:{})});
+  };
+}
+export function createRepositoryScanner(root, options={}) {
+  const limits={...INDEX_LIMITS,...options};
+  const cache=new Map();let running=false,scanId=0;
+  return async function scanRepository({onProgress=()=>{},signal}={}) {
+    if(running)throw new Error('Repository scan already running');
+    running=true;
+    const started=performance.now(),summary=emptyIndexSummary(),scanIssues=[],parsed=[],files=[],seen=new Set();
+    const issue=reporter(summary,scanIssues,limits.issues);
+    const progress={phase:'discovering',scan:++scanId,discovered:0,processed:0,parsed:0,reused:0,batches:0,total:null,elapsedMs:0};
+    let environmentFiles=Infinity;
+    let lastPublished=0,batchFiles=0,batchBytes=0,batchStart=performance.now();
+    const check=()=>signal?.throwIfAborted();
+    const status=()=>({...progress,elapsedMs:Math.round(performance.now()-started)});
+    const publish=async (force=false,results=false)=>{
+      check();
+      if(!force&&performance.now()-lastPublished<limits.publishMs)return;
+      lastPublished=performance.now();
+      // On a first scan, usable declarations arrive in batches. Later scans
+      // retain the last complete index until replacement, avoiding flicker.
+      const index=results?projectIndex(parsed,summary,scanIssues,limits):null;
+      await onProgress({progress:status(),summary:{...summary},...(index?{index:{...index,progress:status()}}:{})});
+    };
+    const batch=async()=>{
+      if(batchFiles<limits.batchFiles&&batchBytes<limits.batchBytes&&performance.now()-batchStart<limits.batchMs)return;
+      progress.batches++;await publish(false,progress.phase==='indexing'&&progress.processed>=environmentFiles&&scanId===1);
+      await yieldThread();check();batchFiles=0;batchBytes=0;batchStart=performance.now();
+    };
+    try {
+      const canonical=await realpath(root),directories=[canonical];
+      await publish(true);
+      // Iterative traversal has no depth/entry ceiling and does not consume
+      // the JS call stack. Symlinks and excluded directories remain excluded.
+      while(directories.length) {
+        check();const dir=directories.pop();
+        try {
+          if(await realpath(dir)!==dir){summary.skipped.symlink++;continue;}
+          const directory=await opendir(dir);
+          for await(const entry of directory) {
+            check();summary.entriesVisited++;
+            const isEnv=/^\.env(?:\.[\w.-]+)?$/.test(entry.name);
+            if(entry.isSymbolicLink())summary.skipped.symlink++;
+            else if(entry.name.startsWith('.')&&!isEnv||excluded.has(entry.name)||privateFile.test(entry.name)||/(?:package-lock|pnpm-lock|yarn\.lock|\.min\.|\.d\.ts$)/.test(entry.name))summary.skipped.policy++;
+            else {
+              const path=join(dir,entry.name);
+              if(entry.isDirectory())directories.push(path);
+              else if(entry.isFile()) {
+                if(isEnv||extensions.has(extname(entry.name))){files.push(path);progress.discovered++;}
+                else summary.skipped.unsupported++;
+              }
+            }
+            // Walking a tree full of unsupported files is still cooperative.
+            batchFiles++;await batch();
+          }
+        }catch(error){check();summary.skipped.unreadable++;issue('unreadable-directory',relative(canonical,dir)||'.');}
+      }
+      const priority=path=>envFile(path)?0:/\.(?:json|ya?ml|toml)$/.test(path)?1:/(?:inference|llm|model|provider|client|agent|router)/i.test(path)?2:3;
+      files.sort((a,b)=>priority(a)-priority(b)||a.localeCompare(b));
+      environmentFiles=files.filter(envFile).length;
+      progress.phase='indexing';progress.total=files.length;await publish(true);
+      for(const path of files) {
+        check();const file=relative(canonical,path);let handle;
+        try {
+          if(await realpath(path)!==path||!path.startsWith(canonical+sep)){summary.skipped.symlink++;continue;}
+          handle=await open(path,constants.O_RDONLY|(constants.O_NOFOLLOW||0)|(constants.O_NONBLOCK||0));
+          const stat=await handle.stat({bigint:true});
+          if(!stat.isFile()){summary.skipped.policy++;continue;}
+          if(stat.size>BigInt(limits.fileBytes)){summary.skipped.oversized++;issue('oversized-file',file);continue;}
+          const fingerprint=[stat.dev,stat.ino,stat.size,stat.mtimeNs,stat.ctimeNs].join(':');
+          seen.add(file);
+          const cached=cache.get(file);
+          let item;
+          if(cached?.fingerprint===fingerprint){item=cached;progress.reused++;}
+          else {
+            const buffer=Buffer.alloc(Math.min(limits.fileBytes+1,Number(stat.size)+1));
+            const {bytesRead}=await handle.read(buffer,0,buffer.length,0);
+            summary.filesRead++;summary.bytesRead+=bytesRead;batchBytes+=bytesRead;
+            if(bytesRead>limits.fileBytes){summary.skipped.oversized++;issue('oversized-file',file);seen.delete(file);continue;}
+            const after=await handle.stat({bigint:true});
+            if([after.dev,after.ino,after.size,after.mtimeNs,after.ctimeNs].join(':')!==fingerprint){issue('changed-during-read',file);seen.delete(file);continue;}
+            const body=buffer.subarray(0,bytesRead).toString('utf8');
+            const hash=digest(body);
+            if(cached?.hash===hash){item={...cached,fingerprint};progress.reused++;}
+            else {
+              const code=/\.(?:py|[cm]?js|jsx|tsx?)$/.test(file);
+              const result=body.includes('\0')?{entries:[],issues:[{code:'binary-file'}]}:code?parseCode(body,file):parseConfig(body,file);
+              // Dotenv bindings are read each scan and discarded after projection;
+              // arbitrary unrelated setting values never enter the cache.
+              item={file,context:contextFor(file),fingerprint,hash,bytes:bytesRead,entries:result.entries.map(cacheEntry),issues:result.issues};
+              progress.parsed++;
+            }
+            if(!envFile(file))cache.set(file,item);
+          }
+          parsed.push(item);summary.filesIndexed++;summary.bytesIndexed+=item.bytes;
+          const format=envFile(file)?'dotenv':extname(file).slice(1);
+          summary.filesByFormat[format]=(summary.filesByFormat[format]||0)+1;
+          for(const note of item.issues)issue(note.code,file,note.line,note.field);
+        }catch(error){check();seen.delete(file);summary.skipped.unreadable++;issue('unreadable-file',file);}
+        finally {await handle?.close();progress.processed++;batchFiles++;await batch();}
+      }
+      for(const file of cache.keys())if(!seen.has(file))cache.delete(file);
+      progress.phase='resolving';await publish(true);
+      const index=projectIndex(parsed,summary,scanIssues,limits);
+      progress.phase='complete';progress.batches++;
+      return {...index,progress:status()};
+    }finally {running=false;}
+  };
+}
+export async function indexRepository(root,limits=INDEX_LIMITS) {
+  return createRepositoryScanner(root,limits)();
+}
+function projectIndex(parsed,scanSummary,scanIssues,limits) {
+  const summary={...scanSummary,unresolved:0,issueCounts:{}},issues=[],references=[];
+  const issue=reporter(summary,issues,limits.issues);
+  // Preserve total issue counts even when the detailed list is bounded.
+  for(const note of scanIssues)issue(note.code,note.file,note.line,note.field);
+  summary.unresolved=scanSummary.unresolved;summary.issueCounts={...scanSummary.issueCounts};
   const envValues=[];
-  for(const item of parsed.filter(p=>envFile(p.file)&&p.context==='application'))for(const e of item.entries)if(e.environmentDeclaration&&e.value)envValues.push({...e,file:item.file});
+  for(const item of parsed.filter(p=>envFile(p.file)&&p.context==='application'))for(const e of item.entries)if(e.environmentDeclaration&&(e.value||e.endpointValue))envValues.push({...e,file:item.file});
+  const environment=new Map();
+  for(const e of envValues){const key=JSON.stringify([dirname(e.file),e.field]);if(!environment.has(key))environment.set(key,[]);environment.get(key).push(e);}
   const resolveEnv=(entry,file)=>{
     if(entry.value!==undefined)return [entry];
     if(!entry.env)return [];
     let dir=dirname(file);
     for(;;){
-      const matching=envValues.filter(e=>e.field===entry.env&&dirname(e.file)===dir);
+      const matching=environment.get(JSON.stringify([dir,entry.env]))||[];
       if(matching.length){
-        const unique=[...new Set(matching.map(e=>e.value))];
+        const unique=[...new Set(matching.map(e=>JSON.stringify([e.value,e.endpointValue])))];
         if(unique.length!==1){issue('ambiguous-environment',file,entry.line,entry.field);return [];}
-        return [{...entry,value:unique[0],basis:'environment-reference',via:{file:matching[0].file,line:matching[0].line}}];
+        return [{...entry,value:matching[0].value,...(matching[0].endpointValue?{endpointValue:matching[0].endpointValue}:{}),basis:'environment-reference',via:{file:matching[0].file,line:matching[0].line}}];
       }
       if(dir==='.')break;dir=dirname(dir);
     }
@@ -118,10 +208,10 @@ export async function indexRepository(root, limits=INDEX_LIMITS) {
     let value=entry.value,endpoint;
     if(kind==='binding')return null;
     if(kind==='endpoint') {
-      endpoint=endpointIdentity(value);
+      endpoint=entry.endpointValue??endpointIdentity(value);
       if(endpoint?.nonInference){issue('non-inference-endpoint',item.file,line,field);return null;}
       if(endpoint?.placeholder){issue('placeholder-endpoint',item.file,line,field);return null;}
-      if(!endpoint){issue('unsupported-endpoint',item.file,line,field);return null;}
+      if(!endpoint||endpoint.invalid){issue('unsupported-endpoint',item.file,line,field);return null;}
       value=endpoint.address;
     }else if(!(kind==='task' ? safeName(value) && value.trim() && !value.includes('://') : modelValue(value))){
       issue(value?.includes('*')?'model-pattern':'unsupported-value',item.file,line,field);return null;
@@ -131,7 +221,6 @@ export async function indexRepository(root, limits=INDEX_LIMITS) {
     const previous=unique.get(id);
     const result={id,kind,value,file:item.file,line,field,basis,context,...(entry.via?{via:entry.via}:{}),...(endpoint?{endpoint}:{}),...(entry.localLibrary?{localLibrary:true}:{}),...extra};
     if(previous){Object.assign(previous,extra);return previous;}
-    if(unique.size>=limits.declarations){summary.truncated=true;return null;}
     unique.set(id,result);return result;
   }
   for(const item of parsed){
@@ -153,7 +242,6 @@ export async function indexRepository(root, limits=INDEX_LIMITS) {
   const resolvedSites=new Set([...unique.values()].filter(r=>r.context==='application').map(r=>[r.kind,r.file,r.line,r.value].join('|')));
   references.push(...[...unique.values()].filter(r=>r.context!=='unlinked'||!resolvedSites.has([r.kind,r.file,r.line,r.value].join('|'))));
   summary.declarations=references.length;
-  if(summary.truncated)issue('scan-limit');
   const inventory=[],models=[], byService=new Map();
   for(const ref of references.filter(r=>r.kind==='endpoint'&&r.context==='application')) {
     const endpoint=ref.endpoint,name=endpoint.service;
@@ -162,13 +250,18 @@ export async function indexRepository(root, limits=INDEX_LIMITS) {
   }
   inventory.push(...byService.values());
   const byId=new Map(references.map(r=>[r.id,r]));
+  const linkedModels=new Set(references.filter(r=>r.kind==='model'&&r.context==='application'&&r.endpointIds?.length).map(r=>`${r.file}:${r.value}`));
+  const byModel=new Map();
   for(const ref of references.filter(r=>r.kind==='model'&&r.context==='application')) {
-    if (!ref.endpointIds?.length && references.some(other => other.kind==='model' && other.context==='application' && other.file===ref.file && other.value===ref.value && other.endpointIds?.length)) continue;
+    if(!ref.endpointIds?.length&&linkedModels.has(`${ref.file}:${ref.value}`))continue;
     const endpoints=(ref.endpointIds||[]).map(id=>byId.get(id)).filter(r=>r?.context==='application').map(r=>r.endpoint);
     // Multiple alternatives do not establish which service supplies this model.
     const services=[...new Set(endpoints.map(e=>e.service))];
     const provider=services.length===1?services[0]:'Unattributed';
-    models.push({id:`declaration:${ref.id}`,name:ref.value,provider,location:'unknown',state:'declared',sourceId:'repository',declarationIds:[ref.id],memoryBytes:null});
+    const key=JSON.stringify([provider,ref.value]);
+    if(byModel.has(key))byModel.get(key).declarationIds.push(ref.id);
+    else byModel.set(key,{id:`declaration:${ref.id}`,name:ref.value,provider,location:'unknown',state:'declared',sourceId:'repository',declarationIds:[ref.id],memoryBytes:null});
   }
+  models.push(...byModel.values());
   return {references,issues,summary,inventory,models,checkedAt:new Date().toISOString()};
 }

package/dist/terminal/src/repository-policy.mjs

@@ -0,0 +1,3 @@
+// Work budgets govern each batch, not the total repository coverage.
+export const INDEX_LIMITS=Object.freeze({batchFiles:32,batchBytes:1024*1024,batchMs:40,publishMs:500,fileBytes:128*1024,issues:100});
+export const emptyIndexSummary=()=>({filesRead:0,filesIndexed:0,bytesRead:0,bytesIndexed:0,entriesVisited:0,filesByFormat:{},skipped:{policy:0,unsupported:0,symlink:0,oversized:0,unreadable:0},truncated:false,declarations:0,unresolved:0,issueCounts:{}});

package/dist/terminal/src/repository-worker.mjs

@@ -0,0 +1,15 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { createRepositoryScanner } from './repository-index.mjs';
+const scan=createRepositoryScanner(workerData.root,workerData.limits);
+let busy=false;
+parentPort.on('message',async message=>{
+  if(message!=='scan'||busy)return;
+  busy=true;
+  try {
+    const index=await scan({onProgress:update=>parentPort.postMessage({type:'progress',...update})});
+    parentPort.postMessage({type:'complete',index});
+  }catch {
+    // Do not send exception messages: filesystem errors can contain paths.
+    parentPort.postMessage({type:'failed'});
+  }finally {busy=false;}
+});

package/dist/terminal/src/server.mjs

@@ -1,6 +1,7 @@
 import { createServer } from 'node:http';
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+import { basename } from 'node:path';
 import { createCollector, loadConfig } from './collect.mjs';
 import { sampleSnapshot } from './sample.mjs';
 
@@ -8,16 +9,16 @@ const assets = new Map([['/', ['index.html', 'text/html']], ['/app.js', ['app.js
 for (const file of ['baseten.png', 'groq.ico', 'cerebras.png', 'qwen.png', 'meta.ico', 'nomic.png', 'baai.png', 'ollama.png', 'lm-studio.png', 'vllm.png', 'anthropic.png', 'google.png', 'deepseek.ico', 'cohere.png', 'openai.png', 'mistral.png', 'openrouter.png', 'huggingface.svg']) assets.set(`/brands/${file}`, [`brands/${file}`, file.endsWith('.svg') ? 'image/svg+xml' : file.endsWith('.ico') ? 'image/x-icon' : 'image/png']);
 
 export async function startTerminal({ root = process.cwd(), port = 4310, interval = 15, demo = false, collect: customCollect, config, fallbackPort = false } = {}) {
-  const collect = customCollect ?? (demo ? async () => sampleSnapshot() : createCollector(root, config ?? await loadConfig(root), interval));
-  let snapshot = await collect();
-  let busy = false;
-  const timer = setInterval(async () => {
-    if (busy) return;
-    busy = true;
-    try { snapshot = await collect(); } catch { /* Keep timestamp: the interface marks stale data. */ }
-    finally { busy = false; }
-  }, interval * 1000);
-  timer.unref();
+  const collect = customCollect ?? (demo ? async () => sampleSnapshot() : createCollector(root, config ?? await loadConfig(root), interval, {backgroundIndex:true}));
+  let snapshot={schemaVersion:1,mode:demo?'sample':'live',loading:true,observedAt:null,interval,project:{name:basename(root),scope:'Current project'},models:[],records:[],sources:[],inventory:[],hosts:[],deployments:[],capacityPools:[],taskSummaries:[]};
+  let busy=false,closed=false,timer;
+  const update=async()=>{
+    if(busy||closed)return;
+    busy=true;
+    try {const next=await collect();if(!closed)snapshot=next;}
+    catch {if(snapshot.loading)snapshot={...snapshot,loadError:true};}
+    finally {busy=false;}
+  };
   const server = createServer(async (request, response) => {
     const address = server.address();
     const validHosts = [`127.0.0.1:${address.port}`, `localhost:${address.port}`];
@@ -29,7 +30,17 @@ export async function startTerminal({ root = process.cwd(), port = 4310, interva
     let path;
     try { path = new URL(request.url, `http://${host}`).pathname; }
     catch { return send(400, '{"error":"Invalid request URL"}'); }
-    if (path === '/api/snapshot') return send(200, JSON.stringify(snapshot));
+    if (path === '/api/snapshot') {
+      const data=collect.current?.(snapshot)??snapshot;
+      const revision=new URL(request.url,`http://${host}`).searchParams.get('repositoryRevision');
+      // Browser refreshes can reuse the unchanged reference catalog. The plain
+      // API still returns a self-contained snapshot for agents and scripts.
+      if(data.repository&&revision!==null&&String(data.repository.revision)===revision) {
+        const {references,...repository}=data.repository;
+        return send(200,JSON.stringify({...data,repository}));
+      }
+      return send(200,JSON.stringify(data));
+    }
     if (path === '/api/sample') return send(200, JSON.stringify(sampleSnapshot()));
     if (path === '/api/info') return send(200, JSON.stringify({ version: 1, defaultMode: demo ? 'sample' : 'live', interval }));
     const asset = assets.get(path);
@@ -37,7 +48,7 @@ export async function startTerminal({ root = process.cwd(), port = 4310, interva
     try { return send(200, await readFile(fileURLToPath(new URL(`../public/${asset[0]}`, import.meta.url))), asset[1]); }
     catch { return send(500, '{"error":"Terminal assets unavailable. Run npm run build."}'); }
   });
-  server.on('close', () => clearInterval(timer));
+  server.on('close', () => { closed=true;clearInterval(timer);void collect.close?.(); });
   const listen = selectedPort => new Promise((resolve, reject) => {
     const onError = error => { server.off('listening', onListening); reject(error); };
     const onListening = () => { server.off('error', onError); resolve(); };
@@ -51,6 +62,9 @@ export async function startTerminal({ root = process.cwd(), port = 4310, interva
       await listen(0);
     }
   }
-  catch (error) { clearInterval(timer); throw error; }
-  return { server, url: `http://127.0.0.1:${server.address().port}`, close: () => new Promise(resolve => { clearInterval(timer); server.close(resolve); server.closeIdleConnections(); }) };
+  catch (error) { closed=true;clearInterval(timer);await collect.close?.();throw error; }
+  // Listen first. The browser can paint while collection and indexing proceed.
+  void update();
+  timer=setInterval(update,interval*1000);timer.unref();
+  return { server, url: `http://127.0.0.1:${server.address().port}`, close: async () => { closed=true;clearInterval(timer);await collect.close?.();await new Promise(resolve=>{server.close(resolve);server.closeIdleConnections();}); } };
 }

package/docs/architecture.md

@@ -46,7 +46,7 @@ Exposes the command surface, supplies private typed intent context, triggers Pi,
 
 The Pi package implements `HarnessAdapter`. It does not define canonical intents, per-intent result contracts, stage transitions, or validation rules.
 
-### Inference Terminal (unreleased)
+### Inference Terminal (0.1.6)
 
 `packages/terminal` supplies a standalone `openmerit dash` executable, passive collectors, a loopback read-only HTTP API, and bundled dark-only browser assets. It does not invoke the coordinator or harness. One collector cycle reads existing metadata and runtime inventory; browser clients receive the same cached snapshot. Imported activity, runtime counters, and sampled whole-machine resources retain their separate scopes. Missing measurements remain unknown, and fictional sample data is isolated from the real snapshot. See the [terminal guide](inference-terminal.md) for the supported sources and JSON contract.
 

package/docs/commands.md

@@ -2,9 +2,9 @@
 
 Run these slash commands inside Pi with the OpenMerit extension loaded. Shell commands such as `pi install` run in your terminal instead.
 
-## Inference Terminal (preview)
+## Inference Terminal
 
-The `openmerit@preview` npm package adds a shell command, `openmerit dash [path]`, for a passive local view of models, connections, usage, and compute. From this checkout, use `npm run dash -- [path]`. It is independent of Pi setup and does not run model comparisons or inference. Published `openmerit@0.1.5` does not include it.
+Install `openmerit@0.1.6` with `npm install -g openmerit` to use the shell command `openmerit dash [path]`, for a passive local view of models, connections, usage, and compute. From this checkout, use `npm run dash -- [path]`. It is independent of Pi setup and does not run model comparisons or inference. Earlier `openmerit@0.1.5` does not include it.
 
 See the [Inference Terminal guide](inference-terminal.md) for local installation, automatic discovery, `--no-discovery`, `--json`, `--demo`, collection intervals, and data limitations. Discovery is part of `dash` and is scoped to application evidence. Coding-harness histories are not collected.
 

package/docs/index.md

@@ -2,7 +2,18 @@
 
 OpenMerit helps your coding harness compare models against the work your product needs to do. You define what matters; the harness gathers measurements and tests candidates; OpenMerit coordinates the process and checks the returned results.
 
-The current release is intended for supervised trials with Pi. Start with a representative task and working evaluations before relying on automatic model changes.
+The optional orchestration integration is intended for supervised trials with Pi. Start with a representative task and working evaluations before relying on automatic model changes.
+
+## View your application inference
+
+Version `0.1.6` includes the local Inference Terminal as an early starting point for OpenMerit. Requires Node.js 22.19 or newer:
+
+```sh
+npm install -g openmerit
+openmerit dash
+```
+
+Run it from your application's directory. See the [Inference Terminal guide](inference-terminal.md) for supported sources, recorded activity, background indexing, and data limits. Pi setup is separate and optional for terminal users.
 
 ## Start with your product