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

package/CHANGELOG.md

@@ -1,5 +1,111 @@
 # Changelog
 
+## 0.1.0-alpha.12 — 2026-10-19
+
+Bench numbers below are from one 800-file project on macOS arm64, Node 22.13.0.
+Released alpha.11 and this build ran interleaved on the same machine; the
+decision path is unchanged within noise (warm `status --sync` 183/410 ms on
+alpha.11, 298/174 ms on alpha.12; states correct, no idle probe launches).
+On a screen of 38 public TypeScript projects in CI, 10 qualified for the
+direct recipe before the run-facts change, 17 after it and 19 after incremental
+and references support. worldmonitor and Recordly now stop at the 5 s probe
+timeout, and open-cowork at its end-checkpoint probe.
+
+- Large installations reach ready quickly. Installed files are observed by
+  identity (inode, size, mode, link count, times), not by hashing their contents;
+  the compiler's own reads stay content-checked by the probe. On macOS:
+  Recordly (75k files in `node_modules`) ready in 7 s instead of failing after
+  120 s; worldmonitor (143k) in 30 s instead of not ready after 15 min.
+  Behavior change: reinstalling identical packages, restoring an installed
+  file's bytes or copying the installation now makes the check STALE once.
+- The direct TypeScript recipe supports TypeScript 6.0.2 and 6.0.3.
+- Claude Code: the typecheck hook also matches a typecheck that starts a `;` or
+  `&&` chain. When it skips one, the message names the rest of the chain. The
+  skill lists the exact commands the hook matches for the selected config.
+- Shorter agent instructions: the CLAUDE.md block is 235 bytes instead of 739,
+  the skill 1.8 KB instead of 5 KB. The reuse rules are unchanged. When the
+  Claude Code hook matches a typecheck, the block no longer points to the
+  skill; the skill stays for agents that look for it.
+- Claude Code hook: it waits for status up to half the last completed run's
+  duration, at most 10 s, instead of a fixed 2 s. Run `redue agent setup claude
+  --apply` again to raise the hook's Claude Code timeout from 5 s to 15 s.
+- Linux: the observer no longer watches `.git` directories. Before, each new
+  directory git created there (on most commits) was an observation gap: status
+  was UNVERIFIED until a full reindex and probe finished, about 5 s on a
+  26k-file project. Input patterns that name a `.git` directory are now
+  refused; REDUE never observed changes there.
+- Direct TypeScript recipe: runs with `declaration: true` are reusable. tsc's
+  declaration checks look up files that building the program does not, and
+  read dependencies' `package.json`; before, any such lookup made the run
+  UNVERIFIED. The receipt now keeps those existence, `realpath` and
+  `package.json` answers as run facts, and status asks them again before every
+  CURRENT answer, including when a cached status is read. Every direct run is
+  now recorded, also one checked by full probes. The probe also records
+  `realpath` while it parses a tsconfig `extends` from a package.
+  Behavior change: a direct receipt recorded by an earlier version is
+  UNVERIFIED until the check runs again (macOS and Linux). Limit: Windows does
+  not record direct runs, so declaration-only lookups are not checked there.
+- Direct TypeScript recipe: a root tsconfig with `incremental: true` is
+  supported. Its build-info file is left out of the inputs, and the run may
+  write only that file. A root tsconfig that references a composite config
+  (such as Vite's `tsconfig.node.json`) is supported when the program does not
+  use the referenced project's files. A `composite` root is still refused.
+- Releases are published to the `latest` npm tag as well as `alpha`, so
+  `npm install -g @redue/cli` installs the newest release.
+
+## 0.1.0-alpha.11 — 2026-10-18
+
+Bench numbers below are from one 800-file project on macOS arm64, Node 22.13.0.
+Released alpha.10 and this build ran back to back on the same machine.
+
+- Faster status decisions for the direct TypeScript recipe on macOS and Linux.
+  The observer checks the compiler's recorded filesystem questions in-process
+  instead of starting a probe that rebuilds the whole program. A full probe runs
+  only when that check fails, the plan or toolchain changes, or observation was
+  interrupted. While idle it no longer starts any probe process.
+  - warm `status --sync`: 741 → 194 ms (+683 → +154 ms over cached `status`)
+  - `status --sync` after an unrelated edit: 619 → 219 ms
+  - `status --sync` after a relevant edit: 1472 → 321 ms. It answers STALE without
+    a full probe when the edited inputs already differ from the receipt.
+  - probe processes started in 20 s idle: 4 → 0
+- Cheaper `redue run` on macOS and Linux. The compiler records its own inputs
+  while it runs, so REDUE no longer probes before and after the compile. After
+  a relevant edit, the run builds the new certificate from that recording instead
+  of running a full probe. Output and exit code are those of plain `tsc`.
+  - repeat run: 4143 → 2752 ms, overhead over plain `tsc` 72% → 16%
+  - run right after a relevant edit: 3990 → 2802 ms, overhead 65% → 18%
+- The direct TypeScript recipe accepts inert Node settings. Before, any non-empty
+  `NODE_*` setting other than `NODE_ENV` kept a check from becoming CURRENT.
+  Now accepted: `NODE_EXTRA_CA_CERTS`, `NODE_PATH`, and `NODE_OPTIONS` made only of
+  `--max-old-space-size`, `--max-semi-space-size`, `--use-openssl-ca`,
+  `--use-bundled-ca`, `--use-system-ca` and `--dns-result-order`. A run under one
+  value is not reused under another. See [Node settings](docs/user/direct-typescript.md#node-settings).
+- `redue agent setup claude --apply` adds a Claude Code hook to
+  `.claude/settings.local.json`. When the agent reruns a configured typecheck
+  that is CURRENT and PASS, the hook blocks it and names the passing run. When
+  the check is not CURRENT, it rewrites the command to `redue run CHECK`, so the
+  result is recorded and the next identical command can be skipped. Prefix a
+  command with `REDUE_FORCE=1` to always run it. On the bench: a skip decision
+  takes about 155 ms; a forced command adds 39 ms. Tested live with Claude Code
+  2.1.302 (`claude -p`). See [the hook](docs/user/agents.md#claude-code-typecheck-hook).
+- Unstable-run and observation-gap reasons now name the failed check or operation.
+- macOS counts each input event once, which removes an intermittent UNVERIFIED
+  after an edit.
+
+Known limits:
+
+- Two bench targets are still missed: warm sync adds 154 ms over cached status
+  (target < 100 ms), and `redue run` adds 16–18% over plain `tsc` (target < 10%).
+- An edit that changes imports, configuration or lib files still costs one full
+  probe, at the end of the next run.
+- Windows keeps the earlier probe-based path, except the STALE shortcut. Yarn
+  and pnpm recipes still probe on each decision. The bench was not run on Linux.
+- The Claude hook covers the Bash tool only, from the project root. It allows the
+  rewritten command without a permission prompt. It judges its own environment,
+  not variables the Bash tool adds from your shell profile.
+- To upgrade, stop observers, install into the same prefix, and keep config, state
+  and receipts. Rerun `redue agent setup claude --apply` to add the hook.
+
 ## 0.1.0-alpha.10 — 2026-10-10
 
 - Combine guarded caller-discovery reuse and cheaper non-reusable recording on

package/README.md

@@ -37,7 +37,7 @@ it; relevant source edits make it stale. [Run the reproducible demo](docs/contri
 
 ## Install the alpha
 
-The opt-in pilot uses **0.1.0-alpha.10**. Follow the
+The opt-in pilot uses **0.1.0-alpha.12**. Follow the
 [fixed-version pilot guide](docs/user/pilot.md) for supported projects, setup,
 updates and voluntary feedback. No external usage results are claimed yet.
 

package/bin/redue.mjs

@@ -9,12 +9,10 @@ import path from 'node:path';
 import {createHash} from 'node:crypto';
 import {spawn,spawnSync} from 'node:child_process';
 import {createRequire} from 'node:module';
-import {fileURLToPath} from 'node:url';
-import {discoverNodeProject} from '../src/node-onboarding.mjs';
+import {fileURLToPath,pathToFileURL} from 'node:url';
 import {processAlive} from '../src/process-liveness.mjs';
 import {samePath,withinPath,realObservedPath} from '../src/path-identity.mjs';
 import {discoverConfig,projectState,canonicalConfig} from '../src/project-location.mjs';
-import {agentCommand} from '../src/agent-integration.mjs';
 import {findExecutable} from '../src/executable-lookup.mjs';
 import {readCachedStatus} from '../src/cached-state.mjs';
 import {assertOwnedStatePlacement} from '../src/owned-state.mjs';
@@ -46,6 +44,12 @@ No checks run in the background. Direct commands outside redue create no receipt
 
 function error(message){console.error(`redue: ${message}`);process.exit(2);}
 const args=process.argv.slice(2);
+if(args.length===3&&args[0]==='agent'&&args[1]==='hook'&&args[2]==='claude'){
+  // Runs before config discovery: the hook must exit 0 on every failure,
+  // because Claude Code treats exit 2 as a block.
+  const {runClaudeHook}=await import('../src/claude-hook.mjs');
+  await runClaudeHook(fileURLToPath(import.meta.url));process.exit(0);
+}
 if(args.length===1&&args[0]==='--version'){console.log(version);process.exit(0);}
 if(args.includes('--help')||args.includes('-h')||!args.length){console.log(help);process.exit(0);}
 let configFile=null,stateOverride=null;
@@ -62,8 +66,12 @@ try{configFile??=command==='init'||stateOverride&&['stop','remove-state'].includ
 catch(e){error(e.message);}
 if(fs.existsSync(path.dirname(configFile)))configFile=canonicalConfig(configFile);
 if(command==='agent'){
+  // Loaded on demand: onboarding and agent setup are not on the run/status path.
+  const {agentCommand}=await import('../src/agent-integration.mjs');
   try{await agentCommand(args,{configFile,stateOverride,entry:fileURLToPath(import.meta.url)});}
   catch(e){error(e.message);}
+  // Exiting with piped output still queued truncates it (8 KB on macOS).
+  await new Promise(resolve=>process.stdout.write('',resolve));
   process.exit(0);
 }
 if(!['init','start','stop','status','detail','explain','run','remove-state'].includes(command))
@@ -88,6 +96,7 @@ if(short&&(command!=='status'||json||sync))error('--short is a cached status opt
 if(dryRun&&command!=='init')error('--dry-run is for init');
 
 if(command==='init'){
+  const {discoverNodeProject}=await import('../src/node-onboarding.mjs');
   let discovery;try{discovery=discoverNodeProject(process.cwd(),{recipe:recipeSelection});}
   catch(e){error(e.message);}
   if(workspaceSelection||checkSelection){
@@ -322,7 +331,13 @@ if(command==='status'&&!sync){
 const details=command==='detail'||command==='explain';
 const internal=command==='remove-state'?'uninstall':
   details?'sync':command==='status'&&sync?'sync':command;
-if(command==='run'){
+// On macOS and Linux the engine runs in this process, which saves a Node startup
+// on every run; its own handlers receive SIGINT and SIGTERM. Windows keeps a
+// child engine because cancellation reaches it over IPC.
+if(command==='run'&&process.platform!=='win32'){
+  process.argv=[process.argv[0],engine,runtimeFile,internal,check,...(!json?['--human']:[])];
+  await import(pathToFileURL(engine).href);
+}else if(command==='run'){
   const child=spawn(process.execPath,[engine,runtimeFile,internal,check,...(!json?['--human']:[])],
     {stdio:['inherit','inherit','inherit','ipc'],env:process.env});
   const forward=signal=>{if(child.exitCode!==null)return;
@@ -337,19 +352,20 @@ if(command==='run'){
   process.off('SIGINT',interrupt);process.off('SIGTERM',terminate);
   if(outcome.error)error(outcome.error.message);
   process.exit(outcome.status??(outcome.signal?128+os.constants.signals[outcome.signal]:1));
+}else{
+  mark('client.engine_submit');
+  const result=spawnSync(process.execPath,[engine,runtimeFile,internal,...(check?[check]:[])],
+    {stdio:['inherit','pipe','inherit'],
+      encoding:'utf8',env:traceEnvironment()});
+  mark('client.engine_complete',{exit:result.status,signal:result.signal});
+  if(result.error)error(result.error.message);
+  if(result.stdout){
+    if(['status','detail','explain'].includes(command)){
+      let value;try{value=JSON.parse(result.stdout);}catch{error('status response could not be read; applicability is unknown');}
+      if(details&&check)value={...value,checks:value.checks.filter(row=>row.name===check)};
+      if(json)console.log(JSON.stringify(value));
+      else console.log(details?renderExplain(value,check):renderStatus(value,{short}));
+    }else printLifecycle(result.stdout,command,json);
+  }
+  process.exit(result.status??1);
 }
-mark('client.engine_submit');
-const result=spawnSync(process.execPath,[engine,runtimeFile,internal,...(check?[check]:[])],
-  {stdio:['inherit','pipe','inherit'],
-    encoding:'utf8',env:traceEnvironment()});
-mark('client.engine_complete',{exit:result.status,signal:result.signal});
-if(result.error)error(result.error.message);
-if(result.stdout){
-  if(['status','detail','explain'].includes(command)){
-    let value;try{value=JSON.parse(result.stdout);}catch{error('status response could not be read; applicability is unknown');}
-    if(details&&check)value={...value,checks:value.checks.filter(row=>row.name===check)};
-    if(json)console.log(JSON.stringify(value));
-    else console.log(details?renderExplain(value,check):renderStatus(value,{short}));
-  }else printLifecycle(result.stdout,command,json);
-}
-process.exit(result.status??1);

package/docs/user/agents.md

@@ -71,6 +71,65 @@ setup requires `--apply`. `--dry-run` never writes. Installing REDUE or running
 `init` does not connect an agent automatically. Setup does not start an observer
 or execute verification. Use `redue start` when you want observation.
 
+## Claude Code typecheck hook
+
+`redue agent setup claude --apply` also adds a PreToolUse hook to
+`.claude/settings.local.json`. The hook needs a local REDUE install, so it is
+per-developer; keep that file out of commits. Other settings in the file are kept,
+but the file is rewritten as 2-space JSON. `.claude/settings.json` is not touched.
+`redue agent remove claude --apply` removes only the entry REDUE added.
+
+The hook skips an exact rerun of a configured typecheck: a check with
+`kind: "typecheck"` or named `typecheck`. It matches these commands, run from the
+project root:
+
+- `redue run CHECK`, or `redue --config FILE run CHECK` when the config is not
+  `redue.config.json`
+- `npm run SCRIPT`, when the check has an npm script
+- `npx tsc --noEmit`, for the direct-TypeScript recipe
+- the check's `command`, when it has no `@` tokens
+
+Each form may end with `2>&1` and then one `| tail -n N`, `| head -n N`,
+`| tail -N` or `| head -N`. It may also be the first command of a `;` or `&&`
+chain. Nothing else matches. Each form has its own `if` rule, so other Bash
+commands never start the hook. The installed skill lists these exact commands,
+so the agent uses forms the hook recognizes.
+
+On a match, the hook runs `redue status --sync --json`. It waits up to half the
+duration of the check's last completed run, at most 10 seconds, so waiting never
+costs more than half a run. With no completed run it waits 2 seconds. A check
+that takes a few hundred milliseconds is therefore rarely skipped; skipping it
+would save almost nothing, and the hook does not rewrite it to `redue run`
+either. Claude Code's own limit for the hook is 15 seconds.
+It blocks the command only when the check is CURRENT, PASS and
+`reuse_eligible: true`. The message names the check and the receipt's run ID. Every
+other result allows the command: STALE, UNVERIFIED, FAILED, a timeout, an error, or
+a missing `redue`. A command that starts with `REDUE_FORCE=1` always runs. A
+blocked chain runs none of its commands; the message names the rest of the chain
+so the agent can run it on its own.
+
+When the check is not CURRENT but the observer answered for it, the hook rewrites
+the command to `redue run CHECK` and allows it, keeping any `2>&1` and
+`| tail`/`| head` suffix. It adds `--config FILE` when the config is not
+`redue.config.json`. The run is recorded, so the next identical command can be
+skipped. Without a healthy answer (timeout, error, no observer) the command runs
+as typed. Claude Code still applies deny and ask rules to the rewritten command.
+A chain is never rewritten: the rewrite is allowed without a prompt, and that
+would also skip the prompt for the rest of the chain.
+
+Limits:
+
+- The hook judges its own environment, which Claude Code passes to it. The Bash
+  tool can add variables from your shell profile. The hook cannot see those.
+- Commands run from a subdirectory, after another command (`cd x && tsc`), or
+  combined with `||`, `&` or other pipes, are not matched.
+- A skip writes nothing. If a typecheck command also emits files, later
+  commands see the files from its last run.
+- Only the Bash tool is covered, not PowerShell.
+- Run setup again after you rename a check or script.
+- The rewrite is allowed without a permission prompt, even where the original
+  command would have prompted.
+
 ## Update an existing connection
 
 Installing a newer package does **not** rewrite project instructions. From the
@@ -107,10 +166,13 @@ historical evidence, but setup may make them STALE or UNVERIFIED. Reassess norma
 and run required checks; an upgrade is not a promise that existing receipts remain
 CURRENT. Do not suppress that invalidation or reset state.
 
-Codex gets a short managed section in project `AGENTS.md` and
-`.agents/skills/redue-verification/SKILL.md`. Claude Code gets a managed section
-in `CLAUDE.md` and `.claude/skills/redue-verification/SKILL.md`. Each uses the same
-policy source; detailed guidance is loaded when verification is relevant. Small
+Codex gets a short managed section in project `AGENTS.md` that points to
+`.agents/skills/redue-verification/SKILL.md`. Claude Code gets one in `CLAUDE.md`
+that names the typecheck command the hook matches and says what a skip means,
+plus `.claude/skills/redue-verification/SKILL.md`. The skill holds the reuse
+rules and the exact commands for the selected config. When the hook matches a
+typecheck, the `CLAUDE.md` section does not point to the skill: the hook does
+the work, and the skill is there for agents that look for it. Small
 ownership records in `.redue/agents/` support safe updates/removal. These are
 portable project files, not receipts; review and commit them if the team wants
 this integration. Do not ignore just the ownership records while committing the
@@ -138,7 +200,8 @@ request; it does not synchronize or run these probes.
 config resolution, cached observer health, a bounded read-only control-access probe,
 managed-file integrity, detected host
 version, and loading guidance. `behavior_verified: false` is deliberate: intact
-files do not prove the agent followed them. No hooks are installed. Doctor neither
+files do not prove the agent followed them. For Claude, doctor reports whether the
+typecheck hook is installed. Doctor neither
 executes checks nor starts observers, reconciles inputs, or installs a host.
 
 Doctor separates missing/unreadable state, a missing or refused endpoint, an
@@ -192,8 +255,8 @@ instruction file containing user content.
 
 Commands from nested directories search toward the nearest Git root. If more than
 one configuration applies, select one with `--config FILE`; REDUE refuses to guess.
-The generated instruction names its project-relative configuration and applies it
-to status/run/explain. External configs or custom machine-local `--state-dir`
+The generated skill names its project-relative configuration and gives the exact
+status and run commands for it. External configs or custom machine-local `--state-dir`
 setups should use a reviewed generic instruction instead of committing absolute
 paths. Other worktrees and remote containers have separate local evidence.
 

package/docs/user/configuration.md

@@ -56,5 +56,22 @@ Advanced explicit contracts may declare `generatedInputs`, `installedInputs`, na
 reviewed escape hatches, not onboarding requirements. A coverage rationale cannot
 override unsupported storage, unresolved links, missing inputs, or observation failure.
 
+Input patterns are relative to the project root. They cannot name a `.git`
+directory, because REDUE does not observe one; `!.git/**` is fine.
+
 Changing commands, relevant configuration, installed material, or consumed inputs
 invalidates prior applicability. It does not erase historical execution outcomes.
+
+Installed inputs (under `node_modules` or other installed roots) are observed by
+file identity: inode, size, mode, link count, and modification and change times.
+REDUE does not read every installed file, so large installations become ready
+quickly. Any write to an installed file makes dependent checks STALE until they
+run again, even when it restores earlier bytes, reinstalls identical packages
+(`npm ci`), copies the installation, or remounts it under another device. Timestamps tick in milliseconds, so a file
+changed in the last 2 seconds could be rewritten at the same size without a new
+identity; `redue run` waits until such files are 2 seconds old before it records
+a checkpoint, which adds up to 2 seconds right after an install. Source files are
+content-hashed, and the direct TypeScript recipe's probe content-checks every file
+the compiler reads. The 2-second window assumes the filesystem clock matches this
+machine's; on a network or VM-shared mount whose clock runs behind, keep the
+installation on a local disk.

package/docs/user/direct-typescript.md

@@ -5,7 +5,7 @@ check against declared, observed inputs and relevant execution context. It does
 not mean npm or npm lifecycle scripts completed.
 
 For a supported single-package npm project with an existing standalone
-`tsc --noEmit` script, installed dependencies, Node 22/24 and TypeScript 5.5.2/5.6.3/5.9.3:
+`tsc --noEmit` script, installed dependencies, Node 22/24 and TypeScript 5.5.2/5.6.3/5.9.3/6.0.2/6.0.3:
 
 ```sh
 redue init --recipe typescript-direct --check typecheck --dry-run
@@ -33,7 +33,7 @@ A generated check contains:
 
 `script` identifies the reviewed source recipe; `command` is what actually runs:
 the resolved Node executable and local TypeScript implementation, with exact argv
-and no shell. TypeScript 5.5.2 and 5.6.3 use `lib/tsc.js`; 5.9.3 uses `lib/_tsc.js` directly,
+and no shell. TypeScript 5.5.2 and 5.6.3 use `lib/tsc.js`; 5.9.3, 6.0.2 and 6.0.3 use `lib/_tsc.js` directly,
 without its outer compile-cache-enabling shim. No compiler is fetched or bundled.
 The entire installed package must match reviewed official distribution bytes.
 
@@ -74,11 +74,49 @@ accidentally when intending to preserve the original selection.
 Pre/post scripts, compound commands, wrappers, environment assignments, workspace
 projects and unsupported compiler versions are not automatically converted.
 Init retains the original script with a reason. Development-mode source-map helpers,
-Node preloads/loaders/compile-cache settings, `TS_ETW_MODULE_PATH` (including empty or case aliases), unsupported compiler plugins or
-incremental/composite configuration, outside-root inputs and uncertain observation
-withhold applicability. Extra custom probes cannot inherit this recipe's context
+Node preloads/loaders/compile-cache settings, `TS_ETW_MODULE_PATH` (including empty or case aliases), unsupported compiler plugins, a
+`composite` root tsconfig, a program that uses a referenced project's files,
+outside-root inputs and uncertain observation withhold applicability. Extra custom probes cannot inherit this recipe's context
 exception. Relevant source, declaration, config, membership and installed-content
-changes invalidate or withdraw applicability normally.
+changes invalidate or withdraw applicability normally. Installed files are observed
+by identity, so reinstalling identical packages or restoring an installed file's
+bytes also needs one rerun (see [configuration](configuration.md)).
+
+A root tsconfig with `incremental: true` is supported. tsc reads and writes
+its build-info file (`tsBuildInfoFile`, or the default next to the config) on
+each run, so REDUE leaves that file out of the inputs and lets the run write
+only that file and the directories it needs; any other write makes the run
+non-reusable. The result is what your own incremental tsc reports, so it
+trusts TypeScript's build-info cache, which TypeScript discards after a
+compiler or option change. The file must be inside the checkout and named
+`*.tsbuildinfo`, with no glob characters in its path.
+`assumeChangesOnlyAffectDirectDependencies` is refused: with it, the result
+depends on earlier runs. REDUE reads the setting when the observer starts:
+after turning `incremental` on or moving the file, restart the observer;
+status says so until then. On Linux, a run that creates the build-info directory is an
+observation gap, so the first run after that is not reusable.
+
+A root tsconfig may reference other configs (`references`), for example a
+composite `tsconfig.node.json`. Plain `tsc --noEmit` reads those configs but
+does not build them, so REDUE treats them as configuration. If the program
+uses a referenced project's sources or built outputs, the check is not
+qualified.
+
+On macOS and Linux, `redue run` records which files the compiler looked up and
+compares them with what the observer's last probe saw. The probe only builds the
+program. With `declaration: true`, tsc also resolves the project's dependencies
+while it checks declarations, so the run looks up files the probe never did,
+some outside the checkout, and reads those dependencies' `package.json`. The
+receipt keeps the run's answers to those existence, `realpath` and
+`package.json` lookups as run facts. Before every CURRENT answer, status asks
+each one again; a cached `redue status` asks them again when it is read. If any
+now answers differently, the check is STALE and the reason names the path. Any
+other file the run read, or a directory it listed, that the probe never did
+still makes the run non-reusable, as do more than 10,000 run facts. Receipts
+with run facts use a new format, so earlier observers do not reuse them. A
+direct receipt recorded before run facts is UNVERIFIED until the check runs
+again. Windows does not record direct runs, so it has no run facts: there, a
+lookup only declaration checks make is not checked again.
 
 The versioned `npm-direct-typescript@1` interpretation retains relevant Node context
 and identity. Reviewed compiler code does not parse npm settings or proxy variables;
@@ -94,3 +132,21 @@ explicit request for `npm run typecheck` is not satisfied by this different comm
 The injected `NODE_USE_ENV_PROXY=1` setting is admitted only on Node 22.13.0,
 where it is inert; it remains strictly tracked. Other Node versions with this
 setting need review and stay unqualified. REDUE does not alter the setting.
+
+## Node settings
+
+Since alpha.11 the direct recipe accepts these `NODE_*` settings:
+
+- `NODE_OPTIONS`, when every token is one of `--max-old-space-size=<n>`,
+  `--max-semi-space-size=<n>`, `--use-openssl-ca`, `--use-bundled-ca`,
+  `--use-system-ca` or `--dns-result-order=ipv4first|ipv6first|verbatim`.
+  Any other flag, quotes, backslashes or tabs are refused.
+- `NODE_EXTRA_CA_CERTS`.
+- `NODE_PATH`.
+
+`NODE_ENV` set to `production`, `test` or empty was already accepted. Every other non-empty
+`NODE_*` setting withholds applicability. The values are part of the recorded
+execution context: a run under one value is not reusable under another. A
+`--require` in `NODE_OPTIONS` still runs inside REDUE's own process before REDUE
+refuses it. The npm, pnpm and Yarn recipes still refuse `NODE_OPTIONS` and
+`NODE_PATH`.

package/docs/user/json.md

@@ -30,6 +30,7 @@ Stable-enough-for-alpha fields:
 | `result` | Historical `PASS`, `FAIL`, or null. A failed invocation is not green even with CURRENT applicability. |
 | `freshness` | `CURRENT`, `STALE`, or `UNVERIFIED`, independent of result. |
 | `reuse_eligible` | True only for qualified, applicable passing evidence. Never derive permission to reuse from outcome alone. Missing means false. |
+| `run_facts` | Number of lookups outside the discovery certificate that the receipt's run made (direct TypeScript recipe). Status asks each again before answering CURRENT. Absent when there are none. |
 | `reason` | Human explanation; not a stable machine enum. Do not parse it to authorize reuse. |
 | `changed_inputs` | Known changed relevant paths when available, possibly only the first difference; empty/missing is not proof of no changes. |
 | `invocation` | Null without a receipt; otherwise run ID, completion `status`, duration, exit code/signal when known. Status distinguishes exited, interrupted, and start/capture failure. |

package/docs/user/pilot.md

@@ -1,4 +1,4 @@
-# Opt-in development pilot: alpha.10
+# Opt-in development pilot: alpha.12
 
 Use one fixed build for several ordinary development sessions. The owner will
 invite two or three willing testers and approve their projects; nothing is
@@ -10,13 +10,14 @@ controlled compiler/agent trials are acceptance evidence, not independent adopti
 Start with a trusted, single-package npm Git checkout, normally installed locked
 dependencies, and an existing standalone `tsc --noEmit` script without pre/post
 scripts. The direct recipe accepts only the official, unchanged TypeScript
-**5.5.2, 5.6.3 or 5.9.3** packages and Node **22 or 24**. No workspaces, named
+**5.5.2, 5.6.3, 5.9.3, 6.0.2 or 6.0.3** packages and Node **22 or 24**. No workspaces, named
 tsconfig selection, emitted/incremental/composite builds, custom loaders or
 outside-root inputs are added by this pilot. Do not downgrade or change your
 project to fit; record an unsupported setup as feedback.
 
 Development-mode source-map support, Node preloads/inspectors/compile-cache
-overrides and `TS_ETW_MODULE_PATH` are unsupported. The injected
+overrides and `TS_ETW_MODULE_PATH` are unsupported. A few inert Node settings
+are accepted; see [Node settings](direct-typescript.md#node-settings). The injected
 `NODE_USE_ENV_PROXY=1` context is reviewed only on Node **22.13.0**; leave the
 environment and security controls intact. See the [full recipe boundary](direct-typescript.md).
 
@@ -24,15 +25,17 @@ CLI/package mechanics are tested on macOS/APFS, native Linux and Windows/NTFS;
 Linux also needs Python 3 and [supported native storage](getting-started.md).
 Actual fresh-session behavior was tested with Codex **0.162.0 on macOS**, Node
 22.13.0 and the approved exact checkout/state/socket access. This is not general
-sandbox compatibility. Claude mechanics are tested; Claude behavior and cross-host
-handoff are **NOT RUN**. The recording shortcut is macOS/direct-recipe only.
+sandbox compatibility. Claude mechanics are tested, and the
+[Claude Code typecheck hook](agents.md#claude-code-typecheck-hook) was exercised in
+Claude Code 2.1.302 (`claude -p`). Broader Claude behavior and cross-host handoff
+are **NOT RUN**. The recording shortcut is macOS/direct-recipe only.
 
 ## Install and connect explicitly
 
 For a new default npm installation:
 
 ```sh
-npm install --global @redue/cli@0.1.0-alpha.10
+npm install --global @redue/cli@0.1.0-alpha.12
 redue --version
 cd my-project
 redue --config redue.config.json init --recipe typescript-direct --check typecheck --dry-run
@@ -86,7 +89,7 @@ using it; keep the same npm prefix, config and any explicit state selection.
 
 ```sh
 redue --config redue.config.json stop
-npm install --global @redue/cli@0.1.0-alpha.10
+npm install --global @redue/cli@0.1.0-alpha.12
 redue --config redue.config.json agent setup codex --dry-run
 redue --config redue.config.json agent setup codex --apply
 redue --config redue.config.json start

package/docs/user/supported-projects.md

@@ -19,7 +19,7 @@ project script. Automatic npm-launcher applicability was withdrawn in alpha.4;
 ordinary npm scripts remain recording-only. See the [maintainer notice](npm-launcher-notice.md).
 The direct recipe is opt-in, available since alpha.5. The opt-in `init --recipe typescript-direct` supports
 a standalone `tsc --noEmit` script in a single-package npm installation using
-reviewed TypeScript 5.5.2/5.6.3/5.9.3 and Node 22/24. It executes the local compiler,
+reviewed TypeScript 5.5.2/5.6.3/5.9.3/6.0.2/6.0.3 and Node 22/24. It executes the local compiler,
 not npm. Full installed compiler identity, config/membership, installed inputs
 and relevant Node environment are checked before reuse. See the
 [exact direct boundary](direct-typescript.md). Unsupported plugins, preloads,
@@ -62,10 +62,10 @@ global virtual stores, injected workspace dependencies, and external links
 without an observed boundary remain recording-only with a reason. Installed
 files with hard-linked aliases outside the checkout remain recording-only on
 macOS: writes through an unseen alias cannot support CURRENT there. On Linux,
-redue watches project-installed file inodes and rehashes the selected
-installed inputs on every synchronized read. A cached read remains UNVERIFIED
-for these pnpm checks; a synchronized read can establish CURRENT after the
-rehash. If an inode watch cannot be installed, observation becomes unavailable
+redue watches project-installed file inodes and re-reads the identity of the
+selected installed inputs on every synchronized read. A cached read remains UNVERIFIED
+for these pnpm checks; a synchronized read can establish CURRENT after that
+re-read. If an inode watch cannot be installed, observation becomes unavailable
 instead of dropping that file. The global store is not watched. An absent
 optional package remains unqualified when Node could later
 resolve it from an unobserved ancestor `node_modules`; project-local candidate

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@redue/cli",
   "private": false,
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.12",
   "publishConfig": {
     "access": "public",
     "tag": "alpha"
@@ -14,7 +14,7 @@
     "test": "node --test --test-concurrency=1 test/*.test.mjs",
     "test:package": "node test/acceptance/package-smoke.mjs",
     "demo": "node test/acceptance/package-smoke.mjs --demo",
-    "pretest": "npm --prefix test/fixtures/typescript-5-5-2 ci --no-audit --no-fund"
+    "pretest": "npm --prefix test/fixtures/typescript-5-5-2 ci --no-audit --no-fund && npm --prefix test/fixtures/typescript-6-0-2 ci --no-audit --no-fund && npm --prefix test/fixtures/typescript-6-0-3 ci --no-audit --no-fund"
   },
   "dependencies": {
     "@parcel/watcher": "2.5.6",