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

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 0.1.0-alpha.32 — 2026-11-05
+
+REDUE's status is now the point: what is verified on the code as it is
+now, what is stale, what is due.
+
+- **`redue verify`.** Runs every check that is due (STALE, or UNVERIFIED
+  with a program that exists), starting the observer if needed, then shows
+  the full status. It exits 0 only when every check that can be verified
+  ends CURRENT / PASS. `--json` gives `verified`, the checks it ran and the
+  status. It runs what is due up to three rounds, since a run can make
+  another check due.
+- **Not verifiable.** A check no run can confirm shows as NOT VERIFIABLE
+  with the reason: a recording-only check, or one whose last two passing
+  runs changed the same inputs while they ran (a test script that rebuilds
+  a tracked bundle). `verify`, its exit code, the end-of-turn check and the
+  status line's due count leave it out; the status line shows it ("✓ 3
+  verified · 1 not verifiable"). Any other change, or a failing run, makes
+  it due again. JSON: `"verifiable": false` and a `not_verifiable` count.
+- **A status line in Claude Code.** `redue setup claude` adds one:
+  "REDUE ✓ 3 verified", "REDUE ✓ 1 verified · 2 due: typecheck, test",
+  "REDUE ✗ 1 failing: lint". A status line you already have stays; setup
+  prints the command instead.
+- **End-of-turn check.** When the agent changed files during a turn and a
+  check is due, the hook asks it once to run `redue verify` before it
+  finishes. It never asks twice in a turn. `"endOfTurnCheck": false` in
+  the config turns it off.
+- **Faster sandboxed runs.** Receipts and checkpoints keep each installed
+  tree (`.venv`, `node_modules`) as one digest, a run computes only its own
+  check's context, and Linux keeps the Landlock probe's answer. What `redue
+  run` adds to a sub-second check on GitHub's Linux runners fell from
+  270-514 ms to 125-205 ms (lighter's ruff 514 to 155 ms); on macOS from
+  390-710 ms to 310-435 ms, where an FSEvents history stall (150-190 ms in
+  about a third of checkpoints) remains. The Landlock launcher now refuses
+  a network-less run on a kernel below ABI 4.
+- **Windows.** A status call before the first `redue start` no longer
+  leaves a file that makes `start` refuse the state directory.
+
+Measured with the verification-gap study (21 tasks on 7 repositories, 2
+runs, Claude Code headless): sessions that ended with every check verified
+on the final code went from 5 of 42 to 41 of 42 with Sonnet 5.5, and from
+20 of 42 to 42 of 42 with Opus 5.5, with no check REDUE called CURRENT /
+PASS failing on the final code. In the product census, 73% of 330 checks
+had a definite answer (CURRENT or STALE) after their second run (alpha.29:
+71%); 97% of those on the sandboxed recipe with ignored files and
+documentation hidden. `init` on the 13 slowest census repos took 3874 s on
+Linux and 4797 s on macOS (alpha.31: 4139 s and 5517 s), with the same
+checks chosen.
+
 ## 0.1.0-alpha.31 — 2026-11-03
 
 A check that runs longer than init's trial limit no longer holds up

package/README.md

@@ -31,8 +31,10 @@ stops before writing anything if the dependencies are not installed. It:
   workflows, Makefile, justfile, tox, nox or scripts give them: mypy,
   pyright and ty (typecheck), ruff (lint) and pytest (test). It says which
   checks it left out and why, and which it can only record, not reuse;
-- connects Claude Code: a short section in `CLAUDE.md`, a skill, and two hooks
-  in `.claude/settings.local.json`;
+- connects Claude Code: a short section in `CLAUDE.md`, a skill, hooks in
+  `.claude/settings.local.json`, and a status line there that shows what is
+  verified on the code as it is now ("REDUE ✓ 3 verified", "REDUE 2 due:
+  typecheck, test"). A status line you already have stays;
 - starts REDUE's file observer, waits while it indexes the project (a minute
   or more in a large one), then runs each check that can qualify once, so
   there is a first result to reuse, and prints one line per run (the run's
@@ -42,7 +44,10 @@ stops before writing anything if the dependencies are not installed. It:
 Then start a new Claude Code session in the project and work as usual. When
 the agent is about to rerun a check whose last pass still applies, the hook
 skips it and tells the agent why. After an edit, the hook runs the check
-through REDUE so the new result is recorded.
+through REDUE so the new result is recorded. When the agent is about to finish a
+turn in which files changed while a check is due, the hook asks it once to
+run `redue verify` first (`"endOfTurnCheck": false` in the config turns
+this off).
 
 To look yourself:
 
@@ -63,6 +68,15 @@ the agent's hook does. `redue status --cached` gives the last answer the
 observer published without checking; it can say UNVERIFIED ("cannot confirm
 your execution context") where `redue status` would say CURRENT.
 
+`redue verify` runs every check that is due (STALE, or UNVERIFIED with a
+command it can run), then prints the status. It exits 0 only when every check
+ends CURRENT / PASS, so it answers "is everything verified on the code as it
+is now?" in one command. A check no run can confirm is shown as NOT
+VERIFIABLE with the reason, and left out: a recording-only check, or one
+whose runs change its own inputs (two passing runs in a row changed the same
+files, such as a test script that rebuilds a tracked bundle). Any other
+change, or a failing run, makes it due again.
+
 `redue stats` shows, per check, the reruns the hook skipped, the time saved,
 the recorded runs and the top reasons a check was UNVERIFIED, from a log kept
 on your machine.
@@ -171,6 +185,7 @@ redue init          # write redue.config.json from your scripts
 redue start         # start the file observer
 redue run typecheck # run a check through REDUE and record the result
 redue status        # what still holds
+redue verify        # run what is due; exit 0 when everything is CURRENT / PASS
 ```
 
 Codex is supported too (`redue agent setup codex --apply`); see

package/bin/redue.mjs

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import {mark,traceBase,traceContext,traceEnvironment,traceId} from '../src/decision-profile.mjs';
 traceBase({...traceContext(),request:traceId(),work:'client'});
-mark('client.loaded');
+mark('client.loaded',{sinceStartMs:Math.round(performance.now())});
 import {directCompiler,directQualification,directEnvironment,directInstalledInputs,directInterpretation} from '../src/direct-typescript.mjs';
 import {runArgv,tscRun} from '../src/typescript-invocation.mjs';
 import {testEnvironment,testRunnerAt,testsInterpretation,testsQualification} from '../src/test-direct.mjs';
@@ -49,6 +49,8 @@ Commands:
   detail [CHECK] [--json]  Alias for explain
   run CHECK [--if-due] Execute one configured check and record its outcome; with --if-due,
                        only when its last pass does not apply to the files as they are now
+  verify [--json]      Run every check that is due (STALE, or UNVERIFIED with a runnable command),
+                       then show the status; exit 0 only when every check is CURRENT / PASS
   stats [--json]       Per check: skips, time saved, recorded runs, why checks were UNVERIFIED
   remove-state         Stop and remove only this configuration's owned local state
 
@@ -66,6 +68,12 @@ if(args.length===3&&args[0]==='agent'&&args[1]==='hook'&&args[2]==='claude'){
   const {runClaudeHook}=await import('../src/claude-hook.mjs');
   await runClaudeHook(fileURLToPath(import.meta.url));process.exit(0);
 }
+// Claude Code's status line, also before config discovery: it prints one
+// line, or nothing where REDUE is not set up.
+if(args.length===3&&args[0]==='agent'&&args[1]==='statusline'&&args[2]==='claude'){
+  const {runStatusLine}=await import('../src/claude-hook.mjs');
+  await runStatusLine(fileURLToPath(import.meta.url));await exit(0);
+}
 if(args.length===1&&args[0]==='--version'){console.log(version);process.exit(0);}
 // Internal: the entry this command runs, so setup and the hook can tell
 // whether the `redue` on PATH (a link, a package manager's shim, a wrapper)
@@ -99,7 +107,7 @@ if(command==='agent'){
   catch(e){error(e.message);}
   await exit(0);
 }
-if(!['init','start','stop','status','detail','explain','run','stats','remove-state'].includes(command))
+if(!['init','start','stop','status','detail','explain','run','verify','stats','remove-state'].includes(command))
   error(`unknown command ${command||'<none>'}; use --help`);
 const json=args.includes('--json');
 // run --if-due: run the check only when its last pass does not apply now.
@@ -319,7 +327,9 @@ if(publicConfig.schema!==1)error('config schema must be 1');
 if(!Array.isArray(publicConfig.checks)||!publicConfig.checks.length)
   error('config needs at least one explicitly defined check');
 for(const key of Object.keys(publicConfig))
-  if(!['schema','root','checks','packageManager'].includes(key))error(`unsupported config field ${key}`);
+  if(!['schema','root','checks','packageManager','endOfTurnCheck'].includes(key))error(`unsupported config field ${key}`);
+// The Claude Code hook's end-of-turn check; only the hook reads it.
+if(publicConfig.endOfTurnCheck!==undefined&&typeof publicConfig.endOfTurnCheck!=='boolean')error('endOfTurnCheck must be true or false');
 if(check&&!publicConfig.checks.some(row=>row.name===check))error(`unknown check ${check}; use redue status to list configured checks`);
 const root=realObservedPath(path.resolve(path.dirname(configFile),publicConfig.root||'.'));
 const state=stateOverride||projectState(root,configFile);
@@ -507,6 +517,75 @@ if(!maintenance&&!created){
   }
 }
 
+if(command==='verify'){
+  const self=(more,options)=>spawnSync(process.execPath,[fileURLToPath(import.meta.url),'--config',configFile,
+    ...(stateOverride?['--state-dir',stateOverride]:[]),...more],{env:process.env,...options});
+  const ask=()=>{const r=self(['status','--sync','--json'],{encoding:'utf8',stdio:['ignore','pipe','ignore'],timeout:600_000});
+    try{return JSON.parse(r.stdout);}catch{return null;}};
+  const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+  let status=ask();
+  // Nothing is confirmed without the observer: start it as the session hook
+  // does, and wait while it indexes.
+  if(!status?.observation?.healthy){
+    let pid=null;try{pid=Number(fs.readFileSync(path.join(state,'observer.lock','pid'),'utf8'));}catch{}
+    if(!(Number.isSafeInteger(pid)&&pid>0&&processAlive(pid))){
+      if(!json)console.error('redue verify: starting the observer');
+      self(['start'],{stdio:['ignore','ignore','inherit']});status=ask();
+    }
+    for(const until=Date.now()+120_000;!status?.observation?.healthy&&
+      ['discovery','indexing','reconciling','validating','initializing'].includes(status?.observation?.phase)&&Date.now()<until;){
+      await sleep(1000);status=ask();}
+  }
+  // A check is due when its last result does not apply to the files as they
+  // are now, and it can run: its program is there.
+  const runnable=row=>{const command=checks.find(item=>item.name===row.name)?.command?.[0];
+    if(typeof command!=='string'||command.endsWith('<unavailable>'))return false;
+    if(command.includes('/'))return fs.existsSync(path.resolve(root,checks.find(item=>item.name===row.name).cwd||'.',command));
+    return Boolean(findExecutable(command));};
+  // A check no run can confirm (recording-only, or one that rewrites its own
+  // inputs: verifiable false) is never due. A run can make another check due
+  // (a suite that writes an input), and a check that rewrites its own inputs
+  // shows that on its second run: verify runs what is due again, three rounds
+  // at most.
+  // In a round, a check whose last run changed its inputs runs first, so the
+  // checks its run makes due run after it.
+  // A check that already ran here is due again only when it is STALE or its
+  // inputs changed during its run: another UNVERIFIED reason would not clear.
+  const changedOwn=row=>/declared input event occurred during execution/.test(row.reason||'');
+  const ranNames=new Set();
+  const dueOf=value=>(value?.checks||[]).filter(row=>row.verifiable!==false&&
+    (row.freshness==='STALE'||row.freshness==='UNVERIFIED'&&runnable(row)&&(!ranNames.has(row.name)||changedOwn(row))))
+    .sort((a,b)=>changedOwn(b)-changedOwn(a));
+  // While the observer indexes or reconciles (a run may have changed a manifest).
+  const settle=async()=>{for(const until=Date.now()+120_000;!status?.observation?.healthy&&
+    ['discovery','indexing','reconciling','validating','initializing'].includes(status?.observation?.phase)&&Date.now()<until;){
+    await sleep(1000);status=ask();}};
+  const {note,dueNote}=await import('../src/stats.mjs');
+  const ran=[];
+  for(let round=0,due=dueOf(status);round<3&&due.length&&status?.observation?.healthy;round++,due=dueOf(status)){
+    for(const row of due){
+      const entry=dueNote(status,row.name);if(entry)note(state,entry);
+      if(!json)console.error(`redue verify: running ${row.name} (${row.freshness}: ${row.reason})`);
+      // With --json, the check's output goes to stderr; stdout carries the answer.
+      const r=self(['run',row.name],{stdio:json?['ignore',2,2]:'inherit'});
+      ran.push({check:row.name,was:row.freshness,exit:r.status});ranNames.add(row.name);
+    }
+    status=ask();await settle();
+  }
+  const final=status;
+  const counted=(final?.checks||[]).filter(row=>row.verifiable!==false);
+  const verified=Boolean(final?.observation?.healthy)&&counted.length>0&&counted.every(row=>row.freshness==='CURRENT'&&row.result==='PASS');
+  if(json)console.log(JSON.stringify({schema:1,verified,ran,status:final}));
+  else{
+    if(ran.length)console.log('');
+    console.log(final?renderStatus(final):'UNVERIFIED — status did not answer.');
+    const other=final?.checks?.length-counted.length;
+    console.log((verified?`Verified: every check that can be verified (${counted.length}) passed on the files as they are now.`:
+      counted.length?'Not verified: some checks did not end CURRENT / PASS.':'Not verified: no check can be verified here.')+
+      (other?` ${other} not verifiable, left out.`:''));
+  }
+  await exit(verified?0:1);
+}
 if(command==='status'&&!sync){
   const value=readCachedStatus(state,publicConfig.checks);
   console.log(json?JSON.stringify(value):renderStatus(value,{short}));

package/docs/user/agents.md

@@ -87,6 +87,32 @@ paths no longer exist. When the hook runs a check through REDUE for the
 agent, it likewise writes plain `redue run` only if its own PATH finds this
 install, else the absolute form.
 
+The same command also runs on UserPromptSubmit and Stop, for the end-of-turn
+check. At the start of a turn it notes the observer's count of file events
+and which checks are CURRENT (on Windows, from a synchronized status). When
+the agent stops, it asks status: if a check is due (STALE or UNVERIFIED) and
+files changed during the 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
+blocks the stop once with "Before you finish, run `redue verify` and report
+what it says". It never asks twice in a turn, and never on the stop that
+follows its reminder (`stop_hook_active`), so it cannot loop. A turn that
+changed nothing ends quietly even when a check is due, and so does any turn
+where the observer is not healthy. `"endOfTurnCheck": false` in the config
+turns it off.
+
+Setup also adds Claude Code's status line, `redue agent statusline claude`,
+in the same file and the same form. It prints one line from a synchronized
+status (the observer's cached one when that takes over 3 s): `REDUE ✓ 3
+verified`, `REDUE ✓ 1 verified · 2 due: typecheck, test`, `REDUE ✗ 1 failing:
+lint`, `REDUE ✓ 3 verified · 1 not verifiable`, `REDUE … checking files` while
+the observer indexes, or `REDUE ? observer not running`. A check that is not
+verifiable (see [the JSON interface](json.md)) is never due, here or for the
+end-of-turn check. Where Claude Code already has a status line (in the
+local or shared project settings, or your user settings), setup leaves it and
+prints the command, so you can add REDUE's line to yours. `redue agent remove
+claude --apply` and `redue remove` take out only REDUE's status line.
+
 Agents often chain an edit and a check (`printf … >> README.md && npm run
 lint`). In a simple chain (commands joined by `&&`, `||` or `;`, with no
 subshell, here-document, command substitution, background job or shell

package/docs/user/configuration.md

@@ -33,6 +33,14 @@ For the explicit direct compiler choice and generated exact argv, see
 A general check (`"qualification": "node-script-v1"`) has a `script` and no
 `command`; see the [general recipe](node-script.md).
 
+## End-of-turn check
+
+With Claude Code, REDUE's hook checks at the end of each agent turn: when the
+turn changed files and a check is due, it asks the agent once to run
+`redue verify` before it finishes ([agents](agents.md)). To turn this off,
+add `"endOfTurnCheck": false` at the top level of the config. Only the hook
+reads it; the observer does not need a restart.
+
 ## Arbitrary commands
 
 An unrecognized ecosystem can still record ordinary execution:

package/docs/user/json.md

@@ -59,3 +59,21 @@ JSON summary. **Its stdout is not a JSON-only stream.** Query status/details aft
 completion for machine-readable evidence. Normal check exit codes are preserved;
 interruption/process-start failures are nonzero. REDUE retains metadata and receipts,
 not arbitrary terminal output. The CLI does not infer tests executed from prose.
+
+A check no run can confirm has `"verifiable": false` (its `freshness` stays
+UNVERIFIED and `reason` says why): a recording-only check (no qualification
+contract, inputs it cannot resolve), or one whose last two runs passed while
+the same inputs changed during them, with its plan, environment and every
+other input unchanged since. Anything else changing, a failing run or a
+clean run makes it verifiable (and due) again. Such checks are counted in
+`not_verifiable`, not in the other counts, and do not set `state`. A cached
+answer (`--cached`) never marks a check this way.
+
+`verify --json` writes one JSON object to stdout: `verified` (true only when the
+observer is healthy, at least one check is verifiable, and every verifiable
+check is CURRENT / PASS), `ran` (each check it ran, in order: `check`, `was`
+(STALE or UNVERIFIED) and the run's `exit`), and `status`, the synchronized
+status after those runs. It runs what is due up to three rounds, since a run
+can make another check due; a check whose last run changed its inputs runs
+first in a round. It never runs a check that is not verifiable. The checks'
+own output goes to stderr. It exits 0 when `verified` is true, else 1.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@redue/cli",
   "private": false,
-  "version": "0.1.0-alpha.31",
+  "version": "0.1.0-alpha.32",
   "publishConfig": {
     "access": "public",
     "tag": "alpha"

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);

package/src/daemon.mjs

@@ -25,7 +25,7 @@ import {npmCacheDir} from './npm-integrity.mjs';
 import {runFromArgv} from './typescript-invocation.mjs';
 import {buildInfoPath,recordedCertificate} from './direct-run-certificate.mjs';
 import {timing,mark,traceBase,traceContext,traceScope,traceEnvironment,traceId} from './decision-profile.mjs';
-import {isSandboxed,sandboxChange,visibleChange as sandboxVisibleChange} from './sandbox.mjs';
+import {compactKey,installedTreeOf,isSandboxed,sandboxChange,visibleChange as sandboxVisibleChange} from './sandbox.mjs';
 
 const configFile=path.resolve(process.argv[2]);
 const config=JSON.parse(fs.readFileSync(configFile));
@@ -338,7 +338,49 @@ function combinedFiles(name) {
     Object.entries(entry.index.exportFiles(name)))files[`external:${entry.root}:${rel}`]=hash;
   return files;
 }
+// The files of a sandboxed run's snapshot and receipt, smaller: each
+// installed tree (a node_modules or .venv directory, outermost) as one entry,
+// `<tree>/:installed:`, with a digest of its files and their identities, and
+// every other file as it is. The fingerprint still covers every file; this map
+// names a changed input and decides which changes a hidden run could see. A
+// receipt says it holds this form (filesCompact), and is compared with it.
+// The entry's name is a path inside its tree, so whether a hidden run could
+// see a change to it is decided as for the files it stands for: beneath a
+// hidden entry, or new where git ignores it now.
+const compactCache=new Map();
+function compactFiles(name) {
+  const summary=combinedSummary(name),key=`${summary.revision}\0${summary.fingerprint}`;
+  const cached=compactCache.get(name);
+  if(cached?.key===key)return {...cached.files};
+  const out={},trees=new Map();
+  for(const [rel,hash] of Object.entries(combinedFiles(name))){
+    const tree=installedTreeOf(rel);
+    if(tree===null){out[rel]=hash;continue;}
+    let list=trees.get(tree);if(!list)trees.set(tree,list=[]);
+    list.push([rel,hash]);
+  }
+  for(const [tree,list] of trees){list.sort(([a],[b])=>a<b?-1:a>b?1:0);out[compactKey(tree)]=sha(JSON.stringify(list));}
+  compactCache.set(name,{key,files:out});
+  return {...out};
+}
+// The current files in the form receipt `r` holds them.
+const filesFor=(name,r)=>r?.filesCompact===true?compactFiles(name):combinedFiles(name);
+// Whether a receipt's run, which passed, is the second in a row during which
+// the same inputs changed (selfChange), and its plan, environment and every
+// other input are as they were at its start.
+function onlySelfChanged(name,row,r,contextHashes) {
+  const self=r.selfChange,context=contextHashes?.[name];
+  if(r.result!=='PASS'||!(self?.streak>=2)||!Array.isArray(self.files)||r.planId!==row.plan.id||!r.files||!context)return false;
+  for(const [key,value] of Object.entries(context))if(!key.startsWith('__redue_env_')&&r.environmentHashes?.[key]!==value)return false;
+  const skip=new Set(self.files),strip=files=>Object.fromEntries(Object.entries(files).filter(([file])=>!skip.has(file)));
+  const before=strip(r.files),now=strip(filesFor(name,r)),paths=[...new Set([...Object.keys(before),...Object.keys(now)])];
+  if(hiddenRun(r))return sandboxVisibleChange(root,r.sandbox.hidden,before,now,paths,{docs:Array.isArray(r.sandbox.docs)?r.sandbox.docs:null})===null;
+  return paths.every(file=>before[file]===now[file]);
+}
+// A changed input as status names it: an installed tree by its path.
+const inputName=file=>file?.endsWith('/:installed:')?file.slice(0,-'/:installed:'.length):file;
 function describeChangedInput(plan,file) {
+  if(file.endsWith('/:installed:'))return `${file.slice(0,-'/:installed:'.length)} (installed files) changed`;
   const boundary=[...external.keys()].find(value=>file.startsWith(`external:${value}:`));
   const physical=boundary?path.join(boundary,file.slice(`external:${boundary}:`.length)):
     path.join(root,file);
@@ -355,7 +397,7 @@ function describeChangedInput(plan,file) {
 const hiddenRun=r=>Array.isArray(r?.sandbox?.hidden)&&Boolean(r.files);
 function visibleChange(row,r,name) {
   const key=(r.invocation?.runId||'')+'\0'+r.fingerprint+'\0'+combinedSummary(name).fingerprint;
-  if(row.visibleKey!==key){const current=combinedFiles(name);
+  if(row.visibleKey!==key){const current=filesFor(name,r);
     row.visibleKey=key;row.visibleChange=sandboxVisibleChange(root,r.sandbox.hidden,r.files,current,[...Object.keys(r.files),...Object.keys(current)],
       {docs:Array.isArray(r.sandbox.docs)?r.sandbox.docs:null});}
   return row.visibleChange;
@@ -389,6 +431,10 @@ function rows(contextHashes,synchronizedInstalled=false,synchronizedFilesystem=f
           `; declared input checkpoint changed (${row.lastReason||'content or membership'})`:'';
       const probeIssue=row.probeError?`; state probe unavailable: ${row.probeError}`:'';
       item.reason='input coverage unresolved: '+row.plan.unresolved.join('; ')+checkpoint+probeIssue;
+      // Recording-only (no qualification contract, inputs it cannot resolve):
+      // no run can make it CURRENT. A qualified check's unresolved inputs can
+      // be fixed, so it stays due.
+      if(!row.plan.qualification)item.verifiable=false;
       return item;
     }
     if(row.probeError){item.reason=row.probeError;return item;}
@@ -410,6 +456,13 @@ function rows(contextHashes,synchronizedInstalled=false,synchronizedFilesystem=f
       item.reason=`target execution ${r.target?.status||'unavailable'}`;return item;}
     if(r.target.status==='failed'&&result!=='FAIL'){
       item.reason='target failure conflicts with outer invocation outcome';return item;}
+    // The same inputs changed during its last two passing runs, and nothing
+    // else changed since: no run of it can be confirmed. Anything else
+    // changing makes it due again.
+    if(!r.stable&&onlySelfChanged(name,row,r,contextHashes)){
+      item.verifiable=false;
+      item.reason=`the same inputs changed during its last two runs (${r.selfChange.files.slice(0,5).join(', ')}${r.selfChange.files.length>5?' and more':''}), so no result of it can be confirmed; it is due again when anything else changes`;
+      return item;}
     if(!r.stable){const issues=r.checkpoint?.issues?.length?` (${r.checkpoint.issues.join('; ')})`:'';
       // A sandboxed run that could not start, whose result the sandbox changed, or whose rerun outside it did not finish, says so alone.
       const sandbox=r.checkpoint?.issues?.length&&r.checkpoint.issues.every(issue=>/^the (?:sandbox changed|run was not sandboxed|run outside the sandbox|network supervisor)/.test(issue));
@@ -446,16 +499,16 @@ function rows(contextHashes,synchronizedInstalled=false,synchronizedFilesystem=f
     else if(r.fingerprint!==combinedSummary(name).fingerprint&&!(hiddenRun(r)&&visibleChange(row,r,name)===null)) {
       const key=r.fingerprint+'\0'+combinedSummary(name).fingerprint;
       if(row.staleReasonKey!==key&&hiddenRun(r)){
-        row.staleInputs=[visibleChange(row,r,name)];row.staleReason=describeChangedInput(row.plan,row.staleInputs[0]);row.staleReasonKey=key;}
+        const seen=visibleChange(row,r,name);row.staleInputs=[inputName(seen)];row.staleReason=describeChangedInput(row.plan,seen);row.staleReasonKey=key;}
       if(row.staleReasonKey!==key){
         let changed=row.lastReason;row.staleInputs=[];
         const candidate=changed?.endsWith(' changed')?changed.slice(0,-8):null;
-        if(candidate&&r.files?.[candidate]!==index.files.get(candidate)){
+        if(candidate&&!(r.filesCompact===true&&installedTreeOf(candidate)!==null)&&r.files?.[candidate]!==index.files.get(candidate)){
           changed=describeChangedInput(row.plan,candidate);row.staleInputs=[candidate];}
         else {
-          const current=combinedFiles(name);
+          const current=filesFor(name,r);
           if(r.files)for(const f of new Set([...Object.keys(r.files),...Object.keys(current)]))
-            if(r.files[f]!==current[f]){changed=describeChangedInput(row.plan,f);row.staleInputs=[f];break;}
+            if(r.files[f]!==current[f]){changed=describeChangedInput(row.plan,f);row.staleInputs=[inputName(f)];break;}
         }
         row.staleReason=changed||
           (['typescript-noemit-v1','npm-typescript-direct-v1','yarn-workspace-tsc-v1','pnpm-tsc-v1']
@@ -500,7 +553,7 @@ function knownStale(name,row) {
   const r=receipts[name];
   if(!r?.files||r.planId!==row.plan.id||row.probeError||pendingChecks.has(name)||
     row.probeCache?.input===inputKey(row))return false;
-  const current=combinedFiles(name),files=Object.keys(current);
+  const current=filesFor(name,r),files=Object.keys(current);
   return files.length!==Object.keys(r.files).length||files.some(file=>r.files[file]!==current[file]);
 }
 // A run can rebuild a certificate that no longer applies only because indexed
@@ -1174,7 +1227,8 @@ async function request(message) {
     if(message.action==='snapshot'||message.action==='prelaunch') {
       data.snapshots={};for(const [name,row] of index?.checks||[])
         if(!message.name||message.name===name)
-          data.snapshots[name]={...combinedSummary(name),files:combinedFiles(name),
+          data.snapshots[name]={...combinedSummary(name),files:message.compact===1?compactFiles(name):combinedFiles(name),
+          ...message.compact===1?{filesCompact:true}:{},
           planGeneration:row.plan.id,
             inputEventSerial:inputEventSerial.get(name)||0,
             // Complete only when the oldest kept event follows the given serial.

package/src/landlock.py

@@ -321,6 +321,9 @@ def main(argv):
     version, err = abi()
     if version is None:
         sys.exit(f'landlock.py: Landlock unavailable (errno {err})')
+    # Below ABI 4 Landlock cannot refuse TCP: a run that must be off the network does not start.
+    if no_tcp and version < 4:
+        sys.exit(f'landlock.py: Landlock ABI {version} cannot keep a run off the network')
     reading = EXECUTE | READ_FILE | READ_DIR
     handled = reading | (WRITE if deny_write else 0)
     attr = RulesetAttr(handled, (BIND_TCP | CONNECT_TCP) if no_tcp and version >= 4 else 0,

package/src/presentation.mjs

@@ -6,7 +6,7 @@ const recipes={'npm-typescript-direct-v1':'direct TypeScript recipe','npm-tests-
   'sandbox-v2':'sandboxed recipe, git-ignored files hidden','sandbox-v3':'sandboxed recipe, git-ignored files and docs hidden'};
 export const recipeLabel=recipe=>recipes[recipe]??null;
 export function checkLabel(row) {
-  return row.result==='FAIL'?'FAILED':row.freshness;
+  return row.verifiable===false?'NOT VERIFIABLE':row.result==='FAIL'?'FAILED':row.freshness;
 }
 export function explanation(row) {
   const reason=row.reason||'No verification evidence is available.';
@@ -25,11 +25,12 @@ export function renderStatus(value,{short=false}={}) {
   const lines=[];
   for(const row of value.checks||[]) {
     const label=checkLabel(row),symbol=label==='CURRENT'&&row.result==='PASS'?'✓':label==='FAILED'?'✗':'?';
-    const mark=label==='STALE'?'⚠':symbol;
+    const mark=label==='STALE'?'⚠':label==='NOT VERIFIABLE'?'–':symbol;
     const historical=row.result?` / ${row.result}`:'';
     const recipe=label==='CURRENT'?recipeLabel(row.recipe):null;
     lines.push(`${mark} ${row.name}  ${label}${historical}${recipe?`  (${recipe})`:''}`);
-    if(label!=='CURRENT')lines.push(`  ${row.result==='FAIL'?`Historical failure; applicability ${row.freshness}. `:''}${explanation(row)}`);
+    if(label==='NOT VERIFIABLE')lines.push(`  Not verifiable: ${explanation(row)}`);
+    else if(label!=='CURRENT')lines.push(`  ${row.result==='FAIL'?`Historical failure; applicability ${row.freshness}. `:''}${explanation(row)}`);
   }
   if(!lines.length)lines.push('UNVERIFIED — observation is initializing; no check state is available yet.');
   if(!value.observation?.healthy)lines.push('Observation unavailable or pending. Previous results are not reusable.');

package/src/sandbox.mjs

@@ -100,8 +100,15 @@ export function sandboxEnvironment(python=false,manager=null,kind=null){
 }
 
 // Whether this machine can sandbox a run: {mode} or {issue}. Asked once per process.
+// On Linux, `cache` (a file in REDUE's state) keeps a Landlock answer for the
+// same kernel, launcher Python and launcher, so a run does not start Python to
+// ask again. The launcher checks again when it starts a run, and a run it
+// cannot sandbox is not reused (launcherFailure).
 let support=null;
-export function sandboxSupport(){
+const launcherKey=python=>{try{const st=fs.statSync(fs.realpathSync(python),{bigint:true});
+  return digest(JSON.stringify([os.release(),python,...['dev','ino','size','mtimeNs'].map(key=>String(st[key])),digest(fs.readFileSync(landlockScript))]));}
+  catch{return null;}};
+export function sandboxSupport({cache=null}={}){
   if(support)return support;
   if(process.env.VSTATE_TEST_FAULTS==='1'&&process.env.VSTATE_TEST_SANDBOX==='unavailable')
     return support={mode:null,issue:'the sandbox is turned off for this test'};
@@ -114,11 +121,15 @@ export function sandboxSupport(){
   if(process.platform==='linux'){
     const python=launcherPython();
     if(!python)return support={mode:null,issue:'the Landlock launcher needs Python 3'};
+    const key=cache?launcherKey(python):null;
+    if(key)try{const kept=JSON.parse(fs.readFileSync(cache,'utf8'));
+      if(kept?.key===key&&Number.isInteger(kept.abi)&&kept.abi>=4)return support={mode:'landlock',abi:kept.abi,python};}catch{}
     let abi=null;
     try{abi=JSON.parse(spawnSync(python,['-I','-W','ignore',landlockScript,'--probe'],{encoding:'utf8',timeout:10000}).stdout).abi;}catch{}
     if(!Number.isInteger(abi))return support={mode:null,issue:'Landlock is unavailable in this kernel'};
     // ABI 4 (Linux 6.7) is the first that can refuse TCP connections.
     if(abi<4)return support={mode:null,issue:`Landlock ABI ${abi} cannot keep a run off the network; it needs ABI 4 (Linux 6.7)`};
+    if(key)try{const temp=`${cache}.${process.pid}.tmp`;fs.writeFileSync(temp,JSON.stringify({key,abi}),{mode:0o600});fs.renameSync(temp,cache);}catch{}
     return support={mode:'landlock',abi,python};
   }
   return support={mode:null,issue:'the sandboxed recipe runs on macOS and Linux only'};
@@ -267,14 +278,19 @@ export function sandboxDirs(state,name){
 // git cannot list them. Only the project's rules count (.gitignore files and
 // .git/info/exclude), not a user's global excludes file, as on CI.
 const installedTree=/(?:^|\/)(?:node_modules|\.venv)(?:\/|$)/;
+// The outermost installed tree a checkout path is in (`a/node_modules`), or
+// null. Never hidden itself; the observer keeps such a tree as one entry in a
+// sandboxed run's files, `<tree>/:installed:` (compactKey).
+export const installedTreeOf=rel=>rel.startsWith('external:')?null:/^(.*?(?:^|\/)(?:node_modules|\.venv))(?:\/|$)/.exec(rel)?.[1]??null;
+export const compactKey=tree=>`${tree}/:installed:`;
+const compactTree=key=>key.endsWith('/:installed:')?key.slice(0,-':installed:'.length):null;
 const runnerCache=picomatch(sandboxCaches,{dot:true});
 const projectGit=['-c','core.excludesFile=/dev/null'],gitEnv=()=>({...process.env,GIT_OPTIONAL_LOCKS:'0'});
+const hiddenArgs=[...projectGit,'ls-files','-z','--others','--ignored','--exclude-standard','--directory'];
+const hiddenOf=r=>r.status!==0?null:r.stdout.split('\0').filter(Boolean).filter(rel=>!installedTree.test(rel)&&
+  !runnerCache(rel)&&!runnerCache(rel.replace(/\/$/,'')+'/x'));
 export function hiddenEntries(root){
-  const r=spawnSync('git',[...projectGit,'ls-files','-z','--others','--ignored','--exclude-standard','--directory'],
-    {cwd:root,encoding:'utf8',maxBuffer:256*1024*1024,timeout:60000,stdio:['ignore','pipe','ignore'],env:gitEnv()});
-  if(r.status!==0)return null;
-  return r.stdout.split('\0').filter(Boolean).filter(rel=>!installedTree.test(rel)&&
-    !runnerCache(rel)&&!runnerCache(rel.replace(/\/$/,'')+'/x'));
+  return hiddenOf(spawnSync('git',hiddenArgs,{cwd:root,encoding:'utf8',maxBuffer:256*1024*1024,timeout:60000,stdio:['ignore','pipe','ignore'],env:gitEnv()}));
 }
 
 // The documentation files docPatterns names among the files git lists and
@@ -283,9 +299,11 @@ export function hiddenEntries(root){
 // Relative; null when git cannot tell. git filters by pathspec, so a large
 // checkout is not listed whole.
 const docMatch=picomatch(docPatterns,{dot:true});
+const docsArgs=()=>[...projectGit,'ls-files','-z','--cached','--others','--exclude-standard','--',...docPatterns.map(pattern=>`:(glob)${pattern}`)];
 export function hiddenDocs(root){
-  const r=spawnSync('git',[...projectGit,'ls-files','-z','--cached','--others','--exclude-standard','--',...docPatterns.map(pattern=>`:(glob)${pattern}`)],
-    {cwd:root,encoding:'utf8',maxBuffer:256*1024*1024,timeout:60000,stdio:['ignore','pipe','ignore'],env:gitEnv()});
+  return docsOf(root,spawnSync('git',docsArgs(),{cwd:root,encoding:'utf8',maxBuffer:256*1024*1024,timeout:60000,stdio:['ignore','pipe','ignore'],env:gitEnv()}));
+}
+function docsOf(root,r){
   if(r.status!==0)return null;
   const out=new Set();
   for(const rel of r.stdout.split('\0'))if(rel&&!out.has(rel)&&docMatch(rel))
@@ -343,7 +361,8 @@ export function visibleChange(root,hidden,before,current,paths,{during=false,doc
   const covered=changed.filter(beneath),fresh=changed.filter(file=>!(file in before)&&!beneath(file));
   if(covered.length){
     const tracked=trackedBeneath(root,entries.filter(entry=>covered.some(file=>file===entry||file.startsWith(entry+'/'))));
-    const found=covered.find(file=>!tracked||tracked.has(file));
+    // An installed tree kept as one entry counts when git tracks any file in it.
+    const found=covered.find(file=>!tracked||tracked.has(file)||compactTree(file)!==null&&[...tracked].some(rel=>rel.startsWith(compactTree(file))));
     if(found)return found;
   }
   if(!fresh.length)return null;
@@ -556,6 +575,11 @@ export function stopGroup(pid){
 export function endWithChild(child){
   child.on('exit',()=>{stopGroup(child.pid);setTimeout(()=>{child.stdout?.destroy();child.stderr?.destroy();},1000).unref();});
 }
+// The launcher's own line when it could not sandbox a run (Landlock
+// unavailable, or a rule it could not add), or null.
+// Only its refusals before the command starts, and only as the run's whole output.
+export const launcherFailure=text=>/^landlock\.py: (?:Landlock unavailable|Landlock ABI \d+ cannot|create_ruleset|add_rule|no_new_privs|restrict_self)[^\n]*$/
+  .exec(String(text).trim())?.[0].slice(0,200)??null;
 // Runs argv in its own process group to the end, with no terminal input:
 // {status, signal, error, timedOut, stdout, stderr}, each output kept up to
 // 64 MB and decoded at the end. `echo` also passes the output through.