@redue/cli 0.1.0-alpha.30 → 0.1.0-alpha.32

package/src/agent-integration.mjs

@@ -11,7 +11,8 @@ import {readProject,projectState,canonicalConfig} from './project-location.mjs';
 import {readCachedStatus} from './cached-state.mjs';
 import {samePath,withinPath} from './path-identity.mjs';
 import {processAlive} from './process-liveness.mjs';
-import {fanoutRules,hookCommand,hookForms,redueFor,runsEntry,shellQuote as quote} from './claude-hook.mjs';
+import os from 'node:os';
+import {fanoutRules,hookCommand,hookForms,redueFor,runsEntry,shellQuote as quote,statusLineCommand} from './claude-hook.mjs';
 
 const policy=fs.readFileSync(new URL('./agent-policy.md',import.meta.url),'utf8');
 const hosts={codex:{instruction:'AGENTS.md',skill:'.agents/skills/redue-verification/SKILL.md'},
@@ -32,18 +33,35 @@ function hookFor(config,relative,scripts,command=hookCommand){
 }
 // The same command on SessionStart starts the observer; it needs no check to match.
 const sessionHookFor=(command=hookCommand)=>({hooks:[{type:'command',command,timeout:10}]});
-const events=['PreToolUse','SessionStart'];
+// And makes the end-of-turn check: UserPromptSubmit notes where the turn
+// starts, Stop asks status (up to 10 s).
+const turnHooksFor=(command=hookCommand)=>({UserPromptSubmit:{hooks:[{type:'command',command,timeout:10}]},
+  Stop:{hooks:[{type:'command',command,timeout:20}]}});
+const events=['PreToolUse','SessionStart','UserPromptSubmit','Stop'];
 // The absolute form: Node and REDUE's entry (redue.mjs), each quoted as quote()
-// writes it. [node, entry] or null.
-function absoluteHook(command){
+// writes it. [node, entry] or null. `use`: hook, or statusline.
+function absoluteHook(command,use='hook'){
   const word="'((?:[^']|'\\\\'')*)'";
-  const match=new RegExp(`^${word} ${word} agent hook claude$`).exec(command??'');
+  const match=new RegExp(`^${word} ${word} agent ${use} claude$`).exec(command??'');
   if(!match)return null;
   const [node,entry]=[match[1],match[2]].map(value=>value.replaceAll("'\\''","'"));
   // REDUE's entry file, or the bin link npm installs for it.
   return /^redue(\.mjs)?$/.test(path.basename(entry))?[node,entry]:null;
 }
 export const isHookCommand=command=>command===hookCommand||Boolean(absoluteHook(command));
+// REDUE's status line, by its command in either form.
+const ownedStatusLine=value=>value?.type==='command'&&(value.command===statusLineCommand||Boolean(absoluteHook(value.command,'statusline')));
+const statusLineFor=command=>({type:'command',command:command.replace(/ agent hook claude$/,' agent statusline claude'),padding:0});
+// Where Claude Code already has a status line that is not REDUE's, which
+// setup leaves alone: the local or shared project settings, or the user's.
+function otherStatusLine(root){
+  const user=path.join(process.env.CLAUDE_CONFIG_DIR||path.join(os.homedir(),'.claude'),'settings.json');
+  for(const [label,text] of [[settingsPath,read(root,settingsPath)],['.claude/settings.json',read(root,'.claude/settings.json')],[user,(()=>{try{return fs.readFileSync(user,'utf8');}catch{return null;}})()]]){
+    let value=null;try{value=JSON.parse(text);}catch{}
+    if(value?.statusLine&&!ownedStatusLine(value.statusLine))return label;
+  }
+  return null;
+}
 // The command Claude Code runs for the hook. Plain `redue` when this install
 // is the one both this shell and a login shell find on PATH. Otherwise this
 // install's Node and entry by absolute path, so a Claude Code started from
@@ -82,10 +100,15 @@ function parseSettings(text){
   return value;
 }
 // Replace REDUE's entry for each event with next[event] (or remove it; a null
-// `next` removes them all). Unchanged input returns the same text, so
-// idempotent setup does not rewrite the file.
+// `next` removes them all), and REDUE's status line with next.statusLine. A
+// status line that is not REDUE's stays. Unchanged input returns the same
+// text, so idempotent setup does not rewrite the file.
 function settingsWith(text,next){
   const value=parseSettings(text);let changed=false;
+  if(value.statusLine===undefined||ownedStatusLine(value.statusLine)){
+    const line=next?.statusLine??undefined;
+    if(!sameJson(line,value.statusLine)){changed=true;if(line)value.statusLine=line;else delete value.statusLine;}
+  }
   for(const event of events){
     const old=value.hooks?.[event]||[],at=old.findIndex(ownedHook),list=old.filter(entry=>!ownedHook(entry));
     if(next?.[event])list.splice(at<0?list.length:at,0,next[event]);
@@ -345,7 +368,7 @@ export async function agentCommand(args,{configFile,stateOverride,entry,cwd=proc
       if(value.state_access)console.log(`State access: ${value.state_access.status}${value.state_access.reason?' — '+value.state_access.reason:''}`);
       if(value.compatibility?.reason)console.log(`Observer compatibility: ${value.compatibility.reason}`);
       if(value.applicability?.requires_reassessment)console.log('Applicability: cached evidence needs reassessment; choose synchronization or execution deliberately.');
-      for(const row of value.hosts)console.log(`${row.host}: ${row.version||'host unavailable'}; integration ${row.integrity}; hook ${row.hook}${row.host==='claude'?`; session start ${row.session_start}`:''}; behavioral validation NOT VERIFIED by doctor${row.reason?' — '+row.reason:''}`);
+      for(const row of value.hosts)console.log(`${row.host}: ${row.version||'host unavailable'}; integration ${row.integrity}; hook ${row.hook}${row.host==='claude'?`; session start ${row.session_start}; status line ${row.status_line}`:''}; behavioral validation NOT VERIFIED by doctor${row.reason?' — '+row.reason:''}`);
       console.log('Doctor does not start observers, execute checks, or prove agent behavior.');
       for(const warning of value.warnings)console.log(`Review: ${warning}`);
     }return value;
@@ -354,7 +377,7 @@ export async function agentCommand(args,{configFile,stateOverride,entry,cwd=proc
   const {root,relative,config}=project(configFile),h=hosts[host],record=saved(root,host),health=inspect(root,host,record);
   if(health.integrity==='conflict')throw Error(health.reason);
   const changes=[],notes=action==='setup'?warnings(root,host,cwd):[];
-  let hook=null,sessionHook=null,block=null;
+  let hook=null,sessionHook=null,statusLine=null,block=null;
   if(action==='setup'){
     const before=read(root,h.instruction),skill=skillFor(relative,host,config);
     block=blockFor(host,blockForms(host,config,relative));
@@ -368,13 +391,19 @@ export async function agentCommand(args,{configFile,stateOverride,entry,cwd=proc
       notes.push('The agent instructions say `redue ...`: put this install on PATH (npm install --global @redue/cli@alpha) so the agent\'s shell can run them. The hook runs the checks it rewrites through this install either way.');
     hook=host==='claude'?hookFor(config,relative,scripts,invocation.command):null;
     sessionHook=host==='claude'?sessionHookFor(invocation.command):null;
+    // The status line, unless Claude Code already shows another one.
+    const other=host==='claude'?otherStatusLine(root):null;
+    if(other)notes.push(`Claude Code already has a status line (${other}); REDUE did not replace it. `+
+      `\`${statusLineFor(invocation.command).command}\` prints REDUE's from the same input, if you want to add it to yours.`);
+    statusLine=host==='claude'&&!other?statusLineFor(invocation.command):null;
     const next={schema:1,host,config:relative,instruction:h.instruction,skill:h.skill,
       block,skillHash:hash(skill),instructionCreated:record?.instructionCreated??before===null};
     changes.push({path:h.skill,before:read(root,h.skill),after:skill},
       {path:h.instruction,before,after});
-    if(host==='claude'){const settings=read(root,settingsPath),next={PreToolUse:hook,SessionStart:sessionHook};
+    if(host==='claude'){const settings=read(root,settingsPath),turn=turnHooksFor(invocation.command),
+        next={PreToolUse:hook,SessionStart:sessionHook,...turn,statusLine};
       changes.push({path:settingsPath,before:settings,after:settingsWith(settings,next),
-        content:JSON.stringify(hook?next:{SessionStart:sessionHook},null,2)+
+        content:JSON.stringify({...hook?{PreToolUse:hook}:{},SessionStart:sessionHook,...turn,...statusLine?{statusLine}:{}},null,2)+
           (hook?'':'\nno PreToolUse hook: no typecheck or test check to match')});}
     changes.push({path:marker(host),before:read(root,marker(host)),after:JSON.stringify(next,null,2)+'\n'});
   }else if(record)changes.push(...removalChanges(root,host,record));
@@ -382,7 +411,7 @@ export async function agentCommand(args,{configFile,stateOverride,entry,cwd=proc
   const summary={schema:1,action,host,config:configFile,applied:false,
     changes:actual.map(c=>({path:c.path,operation:c.after===null?'remove':c.before===null?'create':'update',
       ...(action==='setup'?{content:c.path===h.instruction?block:c.content??c.after}: {})})),
-    warnings:notes,hooks:host!=='claude'||action!=='setup'?'none':`${settingsPath} ${hook?'PreToolUse, ':''}SessionStart`,behavior_verified:false};
+    warnings:notes,hooks:host!=='claude'||action!=='setup'?'none':`${settingsPath} ${hook?'PreToolUse, ':''}SessionStart, UserPromptSubmit, Stop${statusLine?', statusLine':''}`,behavior_verified:false};
   if(!json){console.log(`${action} ${host}: ${configFile}`);
     for(const c of summary.changes)console.log(`  ${c.operation} ${c.path}${c.content?'\n'+c.content:''}`);
     if(!actual.length)console.log('Already in the requested state.');
@@ -433,14 +462,16 @@ export async function doctor({configFile,stateOverride,entry,cwd,host}){
     if(executable){const launch=windowsLaunch([executable,'--version']);
       const out=spawnSync(launch.file,launch.args,{...launch.options,encoding:'utf8',timeout:2000,maxBuffer:4096,stdio:['ignore','pipe','pipe']});
       if(out.status===0)version=out.stdout.trim();}
-    let integration={installed:false,integrity:'unknown'},hook=name==='claude'?'absent':'none',sessionHook=hook;
+    let integration={installed:false,integrity:'unknown'},hook=name==='claude'?'absent':'none',sessionHook=hook,statusLineState=hook;
     const installed=()=>hookRunnable(p.root);
     if(p)try{const record=saved(p.root,name);integration=inspect(p.root,name,record);
       if(name==='claude'&&hookInstalled(p.root))hook=installed();
       if(name==='claude'&&hookInstalled(p.root,'SessionStart'))sessionHook=installed();
+      if(name==='claude'){let local=null;try{local=parseSettings(read(p.root,settingsPath)).statusLine;}catch{}
+        statusLineState=ownedStatusLine(local)?'installed':otherStatusLine(p.root)?'another status line':'absent';}
       value.warnings.push(...warnings(p.root,name,cwd));
     }catch(e){integration={installed:false,integrity:'conflict',reason:e.message};}
-    value.hosts.push({host:name,executable,version,...integration,hook,session_start:sessionHook,behavior_verified:false,
+    value.hosts.push({host:name,executable,version,...integration,hook,session_start:sessionHook,...name==='claude'?{status_line:statusLineState}:{},behavior_verified:false,
       loading:name==='codex'?'AGENTS.md at session start; .agents/skills; overrides and size limits apply':
         'CLAUDE.md at session start; .claude/skills; managed/user policies and exclusions apply'});
   }

package/src/cached-state.mjs

@@ -17,7 +17,8 @@ export function unavailableCached(state,reason,checks=[]) {
   try{const snapshot=readReceiptSnapshot(state);receipts=snapshot.value.checks;revision=snapshot.revision;}
   catch(error){reason+=`; latest receipt unavailable; prior outcome only: ${error.message}`;
     try{receipts=readReceipts(state).checks;}catch{/* retain cached historical rows */}}
-  const rows=(value.checks||[]).map(row=>{
+  // Whether a check can be verified is part of a live answer, not of this one.
+  const rows=(value.checks||[]).map(({verifiable,...row})=>{
     const latest=receipts?.[row.name];
     return {...row,...(receipts?{result:latest?.result||null,invocation:latest?.invocation||null,
       target_provenance:latest?.target||null,coverage_at_run:latest?.coverage||null}:{}),
@@ -25,16 +26,18 @@ export function unavailableCached(state,reason,checks=[]) {
   });
   return {...value,receipt_revision:revision,state:'unverified',current:0,stale:0,failed:0,
     observed_failed:rows.filter(row=>row.result==='FAIL').length,
-    unverified:Math.max(1,rows.length),checks:rows,
+    unverified:Math.max(1,rows.length),not_verifiable:0,checks:rows,
     observation:{...value.observation,healthy:false,reason}};
 }
-// The summary counts of a status answer, from its rows.
+// The summary counts of a status answer, from its rows. A check no run can
+// confirm (verifiable false) is counted apart and does not set the state.
 export function statusSummary(checks) {
-  const count=test=>checks.filter(test).length,failed=count(r=>r.freshness==='CURRENT'&&r.result==='FAIL'),
-    stale=count(r=>r.freshness==='STALE'),unverified=count(r=>r.freshness==='UNVERIFIED')||(!checks.length?1:0);
+  const counted=checks.filter(r=>r.verifiable!==false);
+  const count=test=>counted.filter(test).length,failed=count(r=>r.freshness==='CURRENT'&&r.result==='FAIL'),
+    stale=count(r=>r.freshness==='STALE'),unverified=count(r=>r.freshness==='UNVERIFIED')||(!counted.length?1:0);
   return {state:failed?'failed':unverified?'unverified':stale?'stale':'current',
     current:count(r=>r.freshness==='CURRENT'&&r.result==='PASS'),failed,
-    observed_failed:count(r=>r.result==='FAIL'),stale,unverified};
+    observed_failed:checks.filter(r=>r.result==='FAIL').length,stale,unverified,not_verifiable:checks.length-counted.length};
 }
 // A stored CURRENT answer is only as old as its publish. Run facts are asked
 // again here, from the receipts the answer was about, so no cached answer says

package/src/claude-hook.mjs

@@ -3,6 +3,8 @@
 // CURRENT, the command becomes `redue run <check>` so the run is recorded. Every
 // other outcome, including errors and timeouts, allows the command unchanged.
 // The same command handles SessionStart: it starts the project's observer.
+// UserPromptSubmit and Stop make the end-of-turn check (turnStart, turnEnd).
+// `redue agent statusline claude` prints the status line (statusLine below).
 // Never exit 2: Claude Code treats exit 2 as a block.
 import fs from 'node:fs';
 import path from 'node:path';
@@ -16,6 +18,7 @@ import {findExecutable} from './executable-lookup.mjs';
 import {note,skipNote,dueNote} from './stats.mjs';
 
 export const hookCommand='redue agent hook claude';
+export const statusLineCommand='redue agent statusline claude';
 // No shell metacharacters; `@` starts scoped package names.
 const safe=/^[A-Za-z0-9_./:=,+@-]+$/;
 const typecheck=check=>check?.kind==='typecheck'||check?.name==='typecheck';
@@ -599,12 +602,143 @@ export async function claudeHook(input,{entry,timeout,invoke=null,explain=null})
     updatedInput:{...input.tool_input,command:entered.prefix+rewritten}}}:null);
 }
 
+// The end-of-turn check. UserPromptSubmit notes the observer's event count
+// and generation for the session, and the checks that were CURRENT
+// (turnStart); Stop (turnEnd) asks status, and when a check is due and files
+// changed this turn (the count moved, a check CURRENT at the start is due now,
+// or the turn's transcript has an Edit, Write, MultiEdit or NotebookEdit
+// call), it
+// asks the agent once to run `redue verify` before it finishes. Claude Code
+// marks the Stop that follows with stop_hook_active, which never asks again;
+// the note that it asked does the same. `"endOfTurnCheck": false` in the
+// config turns it off.
+const turnsFile=state=>path.join(state,'turns-v1.json');
+function readTurns(state){
+  try{const value=JSON.parse(fs.readFileSync(turnsFile(state),'utf8'));
+    if(value?.schema===1&&value.sessions&&typeof value.sessions==='object'&&!Array.isArray(value.sessions))return value;}catch{}
+  return {schema:1,sessions:{}};
+}
+// The 20 sessions noted last.
+function writeTurns(state,value){
+  const sessions=Object.fromEntries(Object.entries(value.sessions).sort(([,a],[,b])=>(b?.at??0)-(a?.at??0)).slice(0,20));
+  const temp=`${turnsFile(state)}.${process.pid}.tmp`;
+  try{fs.writeFileSync(temp,JSON.stringify({schema:1,sessions}),{mode:0o600});fs.renameSync(temp,turnsFile(state));}
+  catch{try{fs.rmSync(temp,{force:true});}catch{}}
+}
+const sessionId=input=>typeof input?.session_id==='string'&&/^[A-Za-z0-9_-]{1,128}$/.test(input.session_id)?input.session_id:null;
+// The observer's published status is enough on macOS and Linux. Windows
+// answers from a content reconciliation, not counted events, and its cached
+// status confirms nothing: there the turn starts with a synchronized status.
+export async function turnStart(input,{entry,timeout=5000}={}){
+  let project=null;try{project=hookProject(input?.cwd);}catch{}
+  const id=sessionId(input);
+  if(!project||!id)return null;
+  let state;try{state=projectState(project.projectRoot,project.config);}catch{return null;}
+  let status=null;
+  if(process.platform==='win32'&&entry)status=await synchronizedStatus(entry,project.config,project.projectRoot,timeout);
+  else try{status=JSON.parse(fs.readFileSync(path.join(state,'status.json'),'utf8'));}catch{}
+  const observation=status?.observation;
+  const turns=readTurns(state);
+  turns.sessions[id]={at:Date.now(),generation:typeof observation?.generation==='string'?observation.generation:null,
+    events:Number.isSafeInteger(observation?.events)?observation.events:null,
+    current:observation?.healthy===true&&Array.isArray(status.checks)?status.checks.filter(row=>row?.freshness==='CURRENT').map(row=>row.name):[]};
+  writeTurns(state,turns);
+  return 'noted';
+}
+const editTools=['Edit','Write','MultiEdit','NotebookEdit'];
+// Whether the transcript's last turn, after the user's last prompt, has a
+// call that edits a file. Its last 4 MB are read.
+export function editedThisTurn(transcript){
+  let text='';
+  try{const fd=fs.openSync(transcript,'r');
+    try{const size=fs.fstatSync(fd).size,length=Math.min(size,4*1024*1024),buffer=Buffer.alloc(length);
+      fs.readSync(fd,buffer,0,length,size-length);text=buffer.toString('utf8');}finally{fs.closeSync(fd);}}
+  catch{return false;}
+  const lines=text.split('\n');
+  for(let i=lines.length-1;i>=0;i--){
+    let entry;try{entry=JSON.parse(lines[i]);}catch{continue;}
+    const content=entry?.message?.content;
+    if(entry?.type==='assistant'&&Array.isArray(content)&&content.some(part=>part?.type==='tool_use'&&editTools.includes(part.name)))return true;
+    // The user's prompt: text, not a tool's result.
+    if(entry?.type==='user'&&!entry.isMeta&&(typeof content==='string'||Array.isArray(content)&&content.length&&content.every(part=>part?.type==='text')))return false;
+  }
+  return false;
+}
+export async function turnEnd(input,{entry,timeout=10000,invoke=null}){
+  if(input?.stop_hook_active===true)return null;
+  let project=null;try{project=hookProject(input?.cwd);}catch{}
+  const id=sessionId(input);
+  if(!project||!id||project.parsed.endOfTurnCheck===false)return null;
+  let state;try{state=projectState(project.projectRoot,project.config);}catch{return null;}
+  const turn=readTurns(state).sessions[id];
+  if(turn?.asked)return null;
+  const status=await synchronizedStatus(entry,project.config,project.projectRoot,timeout);
+  if(status?.observation?.healthy!==true||!Array.isArray(status.checks))return null;
+  // A check no run can confirm (verifiable false) is never due.
+  const due=status.checks.filter(row=>row?.verifiable!==false&&(row?.freshness==='STALE'||row?.freshness==='UNVERIFIED'));
+  if(!due.length)return null;
+  const counted=Number.isSafeInteger(turn?.events)&&Number.isSafeInteger(status.observation.events);
+  const changed=counted&&(status.observation.events!==turn.events||status.observation.generation!==turn.generation)||
+    Array.isArray(turn?.current)&&due.some(row=>turn.current.includes(row.name))||
+    typeof input.transcript_path==='string'&&editedThisTurn(input.transcript_path);
+  if(!changed)return null;
+  const turns=readTurns(state);turns.sessions[id]={...turns.sessions[id],at:Date.now(),asked:true};writeTurns(state,turns);
+  const redue=(invoke??redueInvocation(entry))+(project.record.config===defaultConfig?'':` --config ${shellQuote(project.record.config)}`);
+  return {decision:'block',reason:`REDUE: files changed this turn, and ${due.length===1?'a check is':`${due.length} checks are`} due: `+
+    `${due.map(row=>`${row.name} (${row.freshness})`).join(', ')}. Before you finish, run \`${redue} verify\` and report what it says. `+
+    'REDUE asks this once per turn.'};
+}
+
+// Claude Code's status line: one short line from a synchronized status,
+// such as "REDUE ✓ 3 verified" or "REDUE ✓ 1 verified · 2 due: typecheck, test".
+export function statusLineText(status,{observerRunning=true}={}){
+  if(status?.schema!==1||!Array.isArray(status.checks))return 'REDUE ? status unavailable';
+  const observation=status.observation||{};
+  if(observation.healthy!==true)return !observerRunning?'REDUE ? observer not running':
+    ['discovery','indexing','reconciling','validating','initializing'].includes(observation.phase)?'REDUE … checking files':'REDUE ? unverified';
+  const names=rows=>rows.map(row=>row.name).join(', ');
+  const checks=status.checks.filter(row=>row.verifiable!==false),unverifiable=status.checks.length-checks.length;
+  const verified=checks.filter(row=>row.freshness==='CURRENT'&&row.result==='PASS'),
+    failing=checks.filter(row=>row.freshness==='CURRENT'&&row.result!=='PASS'),
+    due=checks.filter(row=>row.freshness!=='CURRENT');
+  const parts=[...verified.length?[`✓ ${verified.length} verified`]:[],...failing.length?[`✗ ${failing.length} failing: ${names(failing)}`]:[],
+    ...due.length?[`${due.length} due: ${names(due)}`]:[],...unverifiable?[`${unverifiable} not verifiable`]:[]];
+  return `REDUE ${parts.join(' · ')||'no checks'}`;
+}
+// The line for the project in the session's directory, or null when REDUE is
+// not set up there. A synchronized status, else the observer's cached one.
+export async function statusLine(input,{entry,timeout=3000}){
+  let project=null;
+  try{project=hookProject(input?.workspace?.project_dir??input?.cwd);}catch{}
+  if(!project)return null;
+  const {config,projectRoot}=project;
+  const status=await synchronizedStatus(entry,config,projectRoot,timeout)??await synchronizedStatus(entry,config,projectRoot,1000,false);
+  let observerRunning=false;
+  try{const pid=Number(fs.readFileSync(path.join(projectState(projectRoot,config),'observer.lock','pid'),'utf8'));
+    observerRunning=Number.isSafeInteger(pid)&&pid>0&&processAlive(pid);}catch{}
+  return statusLineText(status,{observerRunning});
+}
+export async function runStatusLine(entry){
+  try{
+    let text='';process.stdin.setEncoding('utf8');
+    for await(const chunk of process.stdin){text+=chunk;if(text.length>1024*1024)return;}
+    const line=await statusLine(JSON.parse(text),{entry});
+    if(line)await new Promise(resolve=>process.stdout.write(line+'\n',resolve));
+  }catch{}
+}
+
 export async function runClaudeHook(entry){
   try{
     let text='';process.stdin.setEncoding('utf8');
     for await(const chunk of process.stdin){text+=chunk;if(text.length>1024*1024)return;}
     const input=JSON.parse(text);
     if(input?.hook_event_name==='SessionStart'){sessionStart(input,{entry});return;}
+    if(input?.hook_event_name==='UserPromptSubmit'){await turnStart(input,{entry});return;}
+    if(input?.hook_event_name==='Stop'){
+      const output=await turnEnd(input,{entry});
+      if(output)await new Promise(resolve=>process.stdout.write(JSON.stringify(output)+'\n',resolve));
+      return;
+    }
     // REDUE_HOOK_LOG (an absolute file): one JSON line per decision, with why.
     const log=process.env.REDUE_HOOK_LOG,started=Date.now();let why=null;
     const output=await claudeHook(input,{entry,explain:text=>{why=text;}});

package/src/cli.mjs

@@ -8,7 +8,7 @@ import {patternMatcher} from './glob.mjs';
 import {observedBy} from './installed-observation.mjs';
 import {changedFiles,coverageReadable,gitIgnored,recordedEnvironment,testEnvironmentIssue,testGuardConfig,testRunGuard,testRunFacts,sharedInstalledFile,testsInterpretation,testsQualification} from './test-direct.mjs';
 import {childProgram,generalIssue,lookup,pnpmConfigFiles,scriptCaches,scriptInstalledPaths,scriptInterpretation,scriptQualification,scriptRunFacts,pnpmNameless,toolOutput,toolchainDirs} from './node-script.mjs';
-import {denialLine,docsQualification,endWithChild,hiddenDocs,hiddenEntries,hiddenQualification,hiddenRefusal,hidesIgnored,isSandboxed,runToEnd,supervisorIssue,visibleChange,testRun as sandboxTestRun,sandboxArgv,sandboxContext,sandboxDirs,sandboxEnv,
+import {denialLine,docsQualification,endWithChild,launcherFailure,hiddenDocs,hiddenEntries,hiddenQualification,hiddenRefusal,hidesIgnored,isSandboxed,runToEnd,supervisorIssue,visibleChange,testRun as sandboxTestRun,sandboxArgv,sandboxContext,sandboxDirs,sandboxEnv,
   sandboxInterpretation,sandboxInterpretationOf,sandboxPlaces,sandboxQualification,sandboxSupport,systemPlaces} from './sandbox.mjs';
 import path from 'node:path';
 import net from 'node:net';
@@ -31,7 +31,8 @@ import {readCachedStatus,unavailableCached} from './cached-state.mjs';
 import {renderRun} from './presentation.mjs';
 import {note} from './stats.mjs';
 
-mark('cli.loaded');
+// When the engine finished loading, from the process's start.
+mark('cli.loaded',{sinceStartMs:Math.round(performance.now())});
 const here=path.dirname(fileURLToPath(import.meta.url));
 const [configArg,action,name]=process.argv.slice(2);
 if(!configArg||!action)throw Error('internal usage: cli.mjs CONFIG ACTION [check]');
@@ -87,8 +88,10 @@ function environmentReads() {
 }
 const recordedRecipes=[testsQualification,scriptQualification];
 // A sandboxed check's run is recorded where its sandbox cannot start (execute).
-function contextHashes() {const reads=config.checks.some(check=>recordedRecipes.includes(check.qualification)||isSandboxed(check.qualification))?environmentReads():{};
-  return Object.fromEntries(config.checks.map(check=>[
+// `only`: just that check's (a run's checkpoints answer for its own check).
+function contextHashes(only=null) {const checks=only?config.checks.filter(check=>check.name===only):config.checks;
+  const reads=checks.some(check=>recordedRecipes.includes(check.qualification)||isSandboxed(check.qualification))?environmentReads():{};
+  return Object.fromEntries(checks.map(check=>[
   check.name,Object.fromEntries([...(check.environment?.variables||[])
     .map(key=>[key,digest(process.env[key]??'<unset>')]),
     ...(check.environment?.prefixes||[]).map(prefix=>[
@@ -163,7 +166,8 @@ async function decisionCall(message,{timeout,deadline}) {
     const alive=Number.isSafeInteger(pid)&&pid>0?processAlive(pid):null;
     const diagnostic={at:Date.now(),kind:'control_connection_unavailable',code:error.code,
       pid,alive,remainingMs:remaining(),cached:cached().observation};
-    try{fs.appendFileSync(path.join(state,'events.jsonl'),JSON.stringify(diagnostic)+'\n');}catch{}
+    // Only into state this observer owns: start refuses a directory with other files.
+    if(fs.existsSync(ownerFile))try{fs.appendFileSync(path.join(state,'events.jsonl'),JSON.stringify(diagnostic)+'\n');}catch{}
     if(alive){
       // Exactly one reconnect. The sync operation still validates contents;
       // connection recovery by itself is never evidence of applicability.
@@ -253,7 +257,7 @@ async function execute() {
     timing('cli.command_resolution',resolutionStarted);
     const runId=randomUUID();
     const contextStarted=performance.now();
-    const environmentBefore=contextHashes()[name];
+    const environmentBefore=contextHashes(name)[name];
     const observedContext=selected.qualification===directQualification?{interpretation:directInterpretation,npmProxyDigest:observedNpmContext()}:null;
     timing('cli.context_before',contextStarted);
     const captureWait=decisionWait(process.env.VSTATE_CAPTURE_TIMEOUT_MS);
@@ -264,9 +268,13 @@ async function execute() {
     const callerCertificate=directRunCertificateAllowed(selected);
     const probePlan={cwd:plan.cwd,probes:selected.probes||[],qualification:selected.qualification};
     let probeBefore=callerCertificate?null:probeHash(probePlan);
+    // A run the sandbox will run asks for the smaller file map: each
+    // installed tree as one entry (the observer's compactFiles).
+    const supportCache=path.join(state,'sandbox-support-v1.json');
+    const compact=isSandboxed(selected.qualification)&&!sandboxSupport({cache:supportCache}).issue;
     const startSnapshotStarted=performance.now();
-    try{before=await call({action:'snapshot',name,contextHashes:contextHashes(),
-      ...(callerCertificate?{runCertificate:1}:{})},captureWait.timeout,captureWait.deadline);}
+    try{before=await call({action:'snapshot',name,contextHashes:{[name]:environmentBefore},
+      ...(compact?{compact:1}:{}),...(callerCertificate?{runCertificate:1}:{})},captureWait.timeout,captureWait.deadline);}
     catch(error){captureIssues.push('start observation unavailable'+
       (typeof error.code==='string'&&/^[A-Z0-9_]+$/.test(error.code)?` (${error.code})`:''));}
     timing('cli.start_checkpoint',startSnapshotStarted,{available:before?.snapshots?.[name]?1:0});
@@ -326,7 +334,7 @@ async function execute() {
       if(general)launchEnv.npm_config_update_notifier='false';
     }
     // The sandboxed run, with the environment REDUE gives it.
-    let sandbox=null;
+    let sandbox=null;const sandboxSetupStarted=performance.now();
     if(sandboxed&&!fallback){
       if(support.issue)captureIssues.push(`the run was not sandboxed: ${support.issue}`);
       else{
@@ -352,6 +360,7 @@ async function execute() {
           env:sandboxEnv(selected,process.env,{root,...dirs})};
       }
     }
+    if(sandbox)timing('cli.sandbox_setup',sandboxSetupStarted,{hidden:sandbox.hidden?.length??0,docs:sandbox.docs?.length??0});
     const plainEnv={...process.env,...selected.script?{npm_config_update_notifier:'false'}:{}};
     // Output kept, and its own process group, for a run as this recipe makes it.
     const own=sandboxed&&!fallback;
@@ -428,7 +437,7 @@ async function execute() {
     invocation.reporting='normal';
     let result=invocation.status==='exited'?(invocation.exitCode===0?'PASS':'FAIL'):null;
     const target={source:'direct-command',status:invocation.status==='exited'?'direct_executed':'unknown'};
-    const afterContextStarted=performance.now(),environmentAfter=contextHashes()[name];
+    const afterContextStarted=performance.now(),environmentAfter=contextHashes(name)[name];
     timing('cli.context_after',afterContextStarted);
     let probeAfter=null;
     const recordText=Buffer.concat(record).toString('utf8');
@@ -467,7 +476,7 @@ async function execute() {
     if(!unobservedDirectRun){
       // The start checkpoint's probe may have raised the deadline.
       const endWait=decisionWait(process.env.VSTATE_CAPTURE_TIMEOUT_MS);
-      try{after=await call({action:'snapshot',name,contextHashes:contextHashes(),
+      try{after=await call({action:'snapshot',name,contextHashes:{[name]:environmentAfter},...(compact?{compact:1}:{}),
         ...((testRun||sandboxed)&&Number.isSafeInteger(snap?.inputEventSerial)?{sinceSerial:snap.inputEventSerial}:{}),
         ...(recording?{runCertificate:1,adopt:recording}:recorded&&!certificate?{runCertificate:1,runFacts:1}:{})},
         endWait.timeout,endWait.deadline);}
@@ -549,6 +558,10 @@ async function execute() {
     // one runs again in the sandbox without hiding them: the check needs
     // them. That run's result is kept, compared on every file, when the
     // inputs held through it too. Its own refusal is handled as below.
+    // The Landlock launcher could not sandbox the run: nothing it says is a
+    // result, and its kept answer is asked again next time.
+    const unsandboxed=sandbox?.mode==='landlock'&&invocation.exitCode!==0?launcherFailure(output.head):null;
+    if(unsandboxed){captureIssues.push(`the run was not sandboxed: ${unsandboxed}`);result=null;fs.rmSync(supportCache,{force:true});}
     let hiddenRerun=null;
     if((sandbox?.hidden?.length||sandbox?.docs?.length)&&result==='FAIL'&&!requestedSignal){
       const line=hiddenRefusal(output.head+'\n'+output.tail,[...sandbox.hidden||[],...sandbox.docs||[]]);
@@ -567,8 +580,8 @@ async function execute() {
         else{
           const wait=decisionWait(process.env.VSTATE_CAPTURE_TIMEOUT_MS);
           // Inputs, plan, observer and environment held through it as through the first run.
-          let confirmed=null;const environmentNow=contextHashes()[name];
-          try{confirmed=await call({action:'snapshot',name,contextHashes:contextHashes(),
+          let confirmed=null;const environmentNow=contextHashes(name)[name];
+          try{confirmed=await call({action:'snapshot',name,contextHashes:contextHashes(name),
             ...Number.isSafeInteger(snap?.inputEventSerial)?{sinceSerial:snap.inputEventSerial}:{}},wait.timeout,wait.deadline);}catch{}
           const last=confirmed?.snapshots?.[name];
           if(!last?.observationHealthy||!snap||last.planId!==snap.planId||last.fingerprint!==snap.fingerprint||last.revision!==snap.revision||
@@ -612,16 +625,18 @@ async function execute() {
       }
     }
     // A test run whose network was not supervised throughout is not reused.
+    const cleanupStarted=performance.now();
     if(sandbox?.stats){const issue=supervisorIssue(sandbox.stats);if(issue)captureIssues.push(issue);fs.rmSync(sandbox.stats,{force:true});}
-    if(sandbox)fs.rmSync(sandbox.dirs.tmp,{recursive:true,force:true});
+    if(sandbox){fs.rmSync(sandbox.dirs.tmp,{recursive:true,force:true});timing('cli.sandbox_cleanup',cleanupStarted);}
     const stable=captureIssues.length===0;
     // Two runs on the same inputs, environment and plan that disagree make the
     // check nondeterministic until its inputs change.
     let nondeterministic=false;
     const declared=hashes=>Object.entries(hashes||{}).filter(([key])=>!key.startsWith('__redue_env_'));
     if(sandboxRerun)result=invocation.status==='exited'?(invocation.exitCode===0?'PASS':'FAIL'):null;
+    const priorReceipt=readReceipts(state).checks[name];
     if((testRun||sandboxed)&&stable&&result){
-      const prior=readReceipts(state).checks[name];
+      const prior=priorReceipt;
       // A difference explained by inputs REDUE did not observe proves nothing.
       nondeterministic=Boolean(!guard?.issues.length&&prior?.stable&&!prior.guardIssues?.length&&prior.result&&prior.planId===(snap?.planId??plan.id)&&
         prior.fingerprint===((recording||outputs?end:snap)?.fingerprint??null)&&
@@ -634,7 +649,19 @@ async function execute() {
     // predate run facts do not reuse version 2.
     // The recipe that made the receipt, which status and the hook name.
     // A sandboxed receipt names what the run did: hid the git-ignored files or not.
-    const receipt={result,invocation,target,stable,fingerprintVersion:recorded||testRun?2:1,
+    // A run whose only issue is that inputs changed while it ran keeps the
+    // files that did, and how many runs in a row changed the same ones: a
+    // suite that rewrites its own inputs does so on every run (selfChange).
+    let selfChange=null;
+    const eventIssue=captureIssues.find(issue=>issue.startsWith('declared input event occurred during execution'));
+    if(eventIssue&&captureIssues.every(issue=>issue===eventIssue||issue==='declared inputs changed or were not observed')){
+      const files=[...new Set(unexplained||[])].sort().slice(0,20);
+      // Counted only after a passing run of the same plan that changed the same files.
+      if(files.length){const prior=priorReceipt?.selfChange;
+        selfChange={files,streak:prior&&priorReceipt.result==='PASS'&&priorReceipt.planId===(snap?.planId??plan.id)&&
+          JSON.stringify(prior.files)===JSON.stringify(files)?prior.streak+1:1};}
+    }
+    const receipt={result,invocation,target,stable,fingerprintVersion:recorded||testRun?2:1,...selfChange?{selfChange}:{},
       recipe:(fallback?scriptQualification:own?(sandbox?.docs?docsQualification:sandbox?.hidden?hiddenQualification:sandboxQualification):selected.qualification)||null,
       ...(recorded||testRun?{runFacts}:{}),
       ...(testRun?{verificationRecipe:general?scriptInterpretation:testsInterpretation,guardIssues:guard?.issues||['the run record is unavailable'],
@@ -653,7 +680,8 @@ async function execute() {
       ...(own?{verificationRecipe:sandboxInterpretationOf(sandbox?.docs?docsQualification:sandbox?.hidden?hiddenQualification:sandboxQualification,selected.kind),
         sandbox:{mode:sandbox?.mode??null,hidden:sandbox?.hidden??null,...sandbox?.docs?{docs:sandbox.docs}:{},...hiddenRerun?{hiddenRerun}:{},...sandboxRerun?{rerun:sandboxRerun}:{}}}:{}),
       ...(fallback?{sandbox:{mode:null,fallback:'node-script',issue:support.issue}}:{}),
-      files:(outputs?end:snap)?.files??null,observerGeneration:before?.observation?.generation??null,
+      // The form the observer says it returned: an older one ignores the request.
+      files:(outputs?end:snap)?.files??null,...(outputs?end:snap)?.filesCompact===true?{filesCompact:true}:{},observerGeneration:before?.observation?.generation??null,
       startRevision:snap?.revision??null,endRevision:end?.revision??null};
     const persistenceStarted=performance.now();
     commitReceipt(state,name,receipt);