@redue/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/src/cli.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
 import {directQualification,directInterpretation,observedNpmContext} from './direct-typescript.mjs';
-import {directRunCertificateAllowed,validateDirectRunCertificate} from './direct-run-certificate.mjs';
+import {directRunCertificateAllowed,directRunCertificate,directRunRecordable,directRunRecording,probeQuestions,validateRunRecord} from './direct-run-certificate.mjs';
+import {runFactChange} from './typescript-list.mjs';
 import path from 'node:path';
 import net from 'node:net';
 import os from 'node:os';
@@ -225,7 +226,7 @@ async function execute() {
     timing('cli.start_checkpoint',startSnapshotStarted,{available:before?.snapshots?.[name]?1:0});
     // Missing discovery metadata can recover through a full probe. A missing
     // healthy start boundary cannot: freeze this decision before any recovery.
-    // Only the reviewed macOS direct recipe enters this qualification shortcut.
+    // Only the reviewed direct recipe on macOS and Linux enters this shortcut.
     const unobservedDirectRun=callerCertificate&&
       before?.snapshots?.[name]?.observationHealthy!==true;
     if(unobservedDirectRun){
@@ -235,7 +236,22 @@ async function execute() {
     await testRunBoundary('after-start-checkpoint');
     // Start the observed interval before caller validation, not after it. Any
     // intervening edit (even restored before launch) remains disqualifying.
-    if(callerCertificate&&!unobservedDirectRun)probeBefore=validateDirectRunCertificate(plan,selected,before?.snapshots?.[name])??probeHash(probePlan);
+    // With a certificate, the compile records its own answers instead of two probes.
+    // Without one after an edit, the recording can become the certificate at the
+    // end checkpoint; that checkpoint probes in full if it cannot.
+    let certificate=null,recording=null;
+    if(callerCertificate&&!unobservedDirectRun){
+      certificate=directRunCertificate(plan,selected,before?.snapshots?.[name],root);
+      if(!certificate)recording=directRunRecording(plan,selected,before?.snapshots?.[name],root);
+      probeBefore=certificate?.value??(recording?null:probeHash(probePlan));
+    }
+    // The record arrives on fd 3, so the compiler's environment is unchanged.
+    // Every direct run is recorded: even one checked by full probes needs its
+    // lookups outside the certificate, which no probe makes.
+    const recorded=directRunRecordable(selected)&&!unobservedDirectRun;
+    const launched=recorded?[command[0],'--require',path.join(here,'run-recorder.cjs'),
+      ...command.slice(1)]:command;
+    const record=[];
     // A Windows full reconciliation may finish while queued watcher callbacks
     // are still arriving. Fold callbacks delivered before process launch into
     // the starting checkpoint; callbacks after launch still disqualify reuse.
@@ -256,10 +272,11 @@ async function execute() {
       if(requestedSignal){resolve({status:'interrupted',exitCode:null,signal:requestedSignal});return;}
       let child,spawnError=null;
       try{runLock.phase('launching');
-        const launch=windowsLaunch(command);
+        const launch=windowsLaunch(launched);
         child=spawn(launch.file,launch.args,{cwd:plan.cwd,
-        stdio:'inherit',env:process.env,detached:process.platform==='linux',
-        ...launch.options});}
+        stdio:recorded?['inherit','inherit','inherit','pipe']:'inherit',env:process.env,
+        detached:process.platform==='linux',...launch.options});
+        child.stdio[3]?.on('data',chunk=>record.push(chunk));}
       catch(e){resolve({status:'start_failed',exitCode:null,signal:null,errorCode:e.code||e.name});return;}
       activeChild=child;runLock.phase('running',child.pid??null);
       mark('cli.child_started',{childPid:child.pid});
@@ -293,18 +310,52 @@ async function execute() {
     const target={source:'direct-command',status:invocation.status==='exited'?'direct_executed':'unknown'};
     const afterContextStarted=performance.now(),environmentAfter=contextHashes()[name];
     timing('cli.context_after',afterContextStarted);
-    const probeAfter=unobservedDirectRun?null:((callerCertificate?validateDirectRunCertificate(plan,selected,before?.snapshots?.[name]):null)??probeHash(probePlan));
+    let probeAfter=null;
+    const recordText=Buffer.concat(record).toString('utf8');
+    // Lookups the certificate does not cover, kept with the receipt.
+    let runFacts=[];
+    if(certificate){
+      const issue=validateRunRecord(recordText,certificate,runFacts);
+      if(issue)captureIssues.push(`compiler inputs differ from discovery certificate (${issue})`);
+      probeAfter=certificate.value;
+    }else if(!unobservedDirectRun&&!recording)probeAfter=probeHash(probePlan);
+    // The daemon reads the recording from owned state; control requests are small.
+    const recordFile=recording&&path.join(state,`run-record-${recording}.json`);
+    if(recordFile)try{fs.writeFileSync(recordFile,recordText,{mode:0o600});}catch{}
     const endSnapshotStarted=performance.now();
     if(!unobservedDirectRun){
-      try{after=await call({action:'snapshot',name,contextHashes:contextHashes()},captureTimeout);}
+      try{after=await call({action:'snapshot',name,contextHashes:contextHashes(),
+        ...(recording?{runCertificate:1,adopt:recording}:recorded&&!certificate?{runCertificate:1,runFacts:1}:{})},captureTimeout);}
       catch{captureIssues.push('end observation unavailable');}
+      finally{if(recordFile)fs.rmSync(recordFile,{force:true});}
       timing('cli.end_checkpoint',endSnapshotStarted,{available:after?.snapshots?.[name]?1:0});
     }
     const end=after?.snapshots?.[name];
+    // The end certificate, recorded or probed, must cover what this compile received.
+    // With no input event, gap or content change in between, it also holds at the start.
+    // A run checked by full probes is compared with it too, for its run facts.
+    if(recorded&&!certificate){
+      const endCertificate=directRunCertificate(plan,selected,end,root),
+        questions=endCertificate||(!recording&&probeQuestions(plan,selected,end,root));
+      if(!questions)captureIssues.push('no discovery certificate at the end checkpoint');
+      else{
+        const issue=validateRunRecord(recordText,questions,runFacts=[]);
+        if(issue)captureIssues.push(`compiler inputs differ from discovery certificate (${issue})`);
+        if(recording)probeBefore=probeAfter=endCertificate.value;
+      }
+    }
+    // The receipt holds only run facts that still answer as they did during the run.
+    runFacts.sort();
+    if(runFacts.length>10000)captureIssues.push('too many lookups outside the discovery certificate');
+    else{const changed=runFactChange(runFacts);
+      if(changed)captureIssues.push(`a lookup outside the discovery certificate changed during execution: ${changed}`);}
+    if(recording&&snap?.observationGaps!==end?.observationGaps)
+      captureIssues.push('observation gap during execution');
     if(!unobservedDirectRun&&(!end||!end.observationHealthy))captureIssues.push('end checkpoint unavailable');
     if(JSON.stringify(environmentBefore)!==JSON.stringify(environmentAfter))
       captureIssues.push('declared environment changed during execution');
-    if(!unobservedDirectRun&&(!probeBefore||!probeAfter||probeBefore!==snap?.probeHash||probeAfter!==end?.probeHash))
+    if(!unobservedDirectRun&&(!probeBefore||!probeAfter||probeBefore!==(recording?end:snap)?.probeHash||
+      probeAfter!==end?.probeHash))
       captureIssues.push('declared state probe unavailable or changed');
     if(before?.observation?.generation!==after?.observation?.generation)
       captureIssues.push('observer generation changed during execution');
@@ -312,10 +363,14 @@ async function execute() {
       captureIssues.push('input plan rebuilt during execution');
     if(snap?.inputEventSerial!==end?.inputEventSerial)
       captureIssues.push('declared input event occurred during execution');
-    if(!snap||!end||snap.planId!==end.planId||snap.fingerprint!==end.fingerprint||
+    // A recorded certificate changes only the probe part of the fingerprint.
+    if(!snap||!end||snap.planId!==end.planId||(recording?snap.inputKey!==end.inputKey:snap.fingerprint!==end.fingerprint)||
       snap.revision!==end.revision)captureIssues.push('declared inputs changed or were not observed');
     const stable=captureIssues.length===0;
-    const receipt={result,invocation,target,stable,fingerprintVersion:1,
+    // A recorded run's receipt carries its run facts, even none; observers that
+    // predate run facts do not reuse version 2.
+    const receipt={result,invocation,target,stable,fingerprintVersion:recorded?2:1,
+      ...(recorded?{runFacts}:{}),
       resolutionLinks:plan.resolutionLinks||[],
       coverage:{qualified:plan.unresolved.length===0,unresolved:plan.unresolved},
       checkpoint:{status:stable?'stable':'unavailable_or_changed',issues:captureIssues,
@@ -323,7 +378,7 @@ async function execute() {
         ...(process.env.REDUE_PUBLIC_INPUT_TRACE==='1'?{
           startInputEventSerial:snap?.inputEventSerial??null,
           endInputEventSerial:end?.inputEventSerial??null}: {})},
-      planId:snap?.planId??plan.id,fingerprint:snap?.fingerprint??null,
+      planId:snap?.planId??plan.id,fingerprint:(recording?end:snap)?.fingerprint??null,
       provider:plan.provider,environmentHashes:environmentBefore,
       ...(observedContext?{observedContext,verificationRecipe:directInterpretation}:{}),
       files:snap?.files??null,observerGeneration:before?.observation?.generation??null,