@clear-capabilities/agentic-security-scanner 0.128.1 → 0.130.0

package/CHANGELOG.md

@@ -1,5 +1,106 @@
 # Changelog
 
+## 0.130.0 — the roadmap's first ten: provable security over orchestration parity
+
+A capability roadmap (`docs/ROADMAP.md`) plus its first ten items, derived from a
+survey of the current agentic security-review field. The strategic call: that
+field cannot state a false-positive rate or prove it did not regress, because its
+core is a model call. This project's core is a deterministic engine behind three
+gates, so the work doubles down on provable, measurable, reproducible.
+
+- **Execution sandbox** (`src/sandbox/`) — fail-closed confined execution. Verified
+  by execution: writes outside the sandbox root blocked, network blocked, wall-clock
+  overrun terminated, benign work still succeeds. With no confinement primitive
+  available, execution is REFUSED, never run unconfined.
+- **Execution-verified findings** (`posture/execution-proof.js`) — a finding can be
+  promoted to `execution-proven` by running its proof-of-concept in the sandbox.
+  Proof is a marker file, never an exit code, because the sandbox cannot reliably
+  distinguish a denied run from a clean exit. `proof-failed` is a triage signal,
+  NOT a false-positive verdict.
+- **Published accuracy scorecard** (`npm run scorecard`) — detection and correct-
+  silence rates sliced by language and CWE, every figure with its denominator,
+  regeneration-stable. F1 deliberately omitted: no labelled real-world population
+  exists to measure precision over, and the document says so.
+- **Determinism attestation** (`posture/attestation.js`) — an order-independent
+  signed digest. Cross-machine reproducibility is explicitly NOT claimed.
+- **Fixes must pass your tests** (`posture/test-runner.js`) — `verifyFix` previously
+  proved only that the finding disappeared, which deleting the feature also
+  achieves. It now runs the project's own suite, and says so when the suite ran
+  against unpatched code.
+- **Relevance ranking** (`posture/relevance.js`) — re-ranks by entry-point
+  reachability. Recall-preserving: nothing deleted, severity never touched,
+  `unreachable` only on positive evidence.
+- **Enforced verification separation** (`posture/verification-separation.js`) — a
+  verifier cannot rubber-stamp its own finding.
+- **Resumable scans** (`posture/scan-checkpoint.js`) — opt-in via
+  `AGENTIC_SECURITY_RESUME=1`, crash-safe, conservatively invalidated.
+- **Secret redaction** (`llm-validator/redact.js`) — credentials removed before any
+  code leaves the machine; ordinary code passes through byte-unchanged.
+
+Also: dependencies updated to latest (Babel 7→8 with the removed preset options
+migrated, js-yaml 4→5 with an empty-input shim). One dependency deliberately held
+back: bumping the grammar runtime silently drops all six long-tail language
+grammars, so it stays pinned and the reason is documented.
+
+`npm test` 1989/0; cve-replay 199/199; self-scan no drift.
+
+## 0.129.0 — closing two taint-engine recall gaps
+
+Two defects were found by execution on the merged tree, each silencing real findings across
+every supported language. Both are now fixed, measured, and gated.
+
+- **Sinks are matched on assignment right-hand sides** (`dataflow/engine.js`). The engine only
+  ever sink-matched in statement position, so `db.query(tainted)` was reported while
+  `const rows = db.query(tainted)` was silent — in every language. The sink-matching logic is
+  now extracted into shared helpers called from both `case 'call'` and `case 'assign'` rather
+  than duplicated, and the pre-existing statement-position path is unchanged (measured control:
+  `1/1` before and after; assignment position `0/0 -> 1/1`).
+- **`match.type:'global'` catalog entries are indexed and reachable** (`dataflow/catalog.js`).
+  All 10 global entries were unreachable from `matchSource()` — including `$_GET`/`$_POST`/
+  `$_REQUEST`, the canonical PHP taint sources, in a language that already had interprocedural
+  analysis. A new `GLOBAL_INDEX`, plus lookup-side sigil normalization (`_globalKey()`) so PHP's
+  `$` prefix matches sigil-free catalog keys, takes catalog reachability `0/10 -> 10/10` with
+  language scoping preserved.
+- **Seven self-scan false positives eliminated at source.** Raising sink recall exposed
+  pre-existing catalog imprecision: `py-yaml-load`/`py-pickle-load` matched bare callee `load`
+  with no receiver constraint, so ordinary `json.load(fh)` was flagged as unsafe deserialization.
+  Each finding was inspected individually and all seven were false positives; the entries are now
+  pinned to their receiver. **Nothing was baselined** — `bench/self-scan/BASELINE.json` is
+  unchanged and the gate is green on the source fix.
+- **New**: `bench/engine-recall` before/after harness (`npm run bench:engine-recall`) and
+  `bench/engine-recall/RESULTS.md`, the full measurement record including what the fixes cost.
+- **Corpus 197 -> 199**: two deep-tier entries, each verified missed-before / found-after against
+  its specific fix.
+
+Known trade, recorded rather than papered over: pinning the receiver drops `import yaml as y;
+y.load(f)` and `from yaml import load; load(x)`, which are now covered at no layer. A corpus guard
+was attempted and deliberately withheld because it would score `pre:TN`; closing it needs
+import-alias resolution in the Python IR. Separately, `10/10` is catalog reachability, not
+end-to-end recall — only PHP is proven end to end; Ruby's deep engine does not complete those
+flows (pre-existing). Both are documented in `RESULTS.md` §3 and §8.
+
+`npm test` 1854/0; cve-replay 199/199; self-scan no drift.
+
+## 0.128.2 — compliance attestation accuracy + quieter self-scans
+
+Two fixes surfaced while dogfooding the compliance flow on this repo:
+
+- **Fixed a compliance-attestation path bug** (`posture/auditor-walkthrough.js`). Three
+  evidence checks (`mcp-tools`, `security-fixer`, `pre-edit-bodyguard`) carried a literal
+  `.../` placeholder path that `path.join(scanRoot, STATE, '.../x')` could never resolve, so
+  they read **"not present" for every project** — falsely dragging OWASP LLM08/LLM09 (and any
+  framework mapping to those modules) to "manual/not-present". A `.../` sentinel now resolves
+  against the scan root itself. On a self-attestation this flips LLM09 → satisfied and makes
+  LLM08 honestly partial.
+- **Repo `ignorePaths` for meaningful self-scans** (`.agentic-security/rules.yml`). Added
+  `bench/**` and `scanner/test/fixtures/**` so a repo-root `/scan` no longer counts the ~600
+  intentionally-vulnerable benchmark corpora and test fixtures as findings. Safe: `rules.yml`
+  is loaded from the exact scan root only, so the cve-replay runner (which scans each
+  pre/post fixture as its own root) and the unit tests are unaffected — corpus gate stays
+  185/185.
+
+`npm test` 1695/0; cve-replay 185/185.
+
 ## 0.128.1 — patch dependency vulnerabilities (11 Dependabot alerts → 0)
 
 Security maintenance. Cleared all 11 open Dependabot alerts by updating the two lockfiles to

package/bin/agentic-security.js

@@ -274,6 +274,21 @@ function renderV3Blocks(scan, flags) {
 }
 
 // Always-on machine output (R2). Vibecoder gets JSON only; pro gets JSON+SARIF+CSV.
+// SHA-256 of the running bundle, read from the sidecar `npm run build` emits
+// NEXT TO the bundle. Running from source (bin/ + src/) yields 'unavailable'
+// rather than the checkout's dist hash: src and a previously-built dist can
+// disagree, and attesting a bundle that did not produce this run would be a
+// false claim.
+function _bundleSha() {
+  const here = path.dirname(new URL(import.meta.url).pathname);
+  try {
+    const raw = fs.readFileSync(path.join(here, 'agentic-security.mjs.sha256'), 'utf8').trim();
+    const m = /^([0-9a-f]{64})\b/.exec(raw);
+    if (m) return m[1];
+  } catch { /* not running from the bundle */ }
+  return 'unavailable';
+}
+
 async function writeMachineOutput(targetAbs, scan, meta, profile) {
   const stateDir = path.join(targetAbs, '.agentic-security');
   const { isSafeStateDir: _isSafe } = await import('../src/posture/state-dir.js');
@@ -553,6 +568,24 @@ async function cmdScan(args) {
   // Deterministic post-process: stable-sort findings + zero out timing.
   if (isDeterministic()) makeDeterministic(scan, meta);
 
+  // R4 — determinism as a contract. Bind the PUBLISHED finding set (the same
+  // normalization every report format emits) to the engine version, ruleset
+  // version and bundle hash that produced it, via an order-independent digest.
+  // Runs after every filter above so it attests what actually ships. Metadata
+  // only — a failure here must never fail a scan.
+  try {
+    const { computeRunAttestation } = await import('../src/posture/attestation.js');
+    const { effectiveVersion } = await import('../src/posture/ruleset-version.js');
+    scan.attestation = computeRunAttestation({
+      findings: normalizeFindings(scan),
+      engineVersion: PKG_VERSION,
+      rulesetVersion: effectiveVersion(targetAbs).version,
+      bundleSha: _bundleSha(),
+      root: targetAbs,
+      sign: true,
+    });
+  } catch { /* attestation is metadata; never fail a scan over it */ }
+
   // R2: Always emit machine-readable artifacts to .agentic-security/.
   await writeMachineOutput(targetAbs, scan, meta, profile);
 

package/dist/11.index.js

@@ -21,8 +21,8 @@ var external_node_child_process_ = __webpack_require__(1421);
 var external_node_fs_ = __webpack_require__(3024);
 // EXTERNAL MODULE: external "node:path"
 var external_node_path_ = __webpack_require__(6760);
-// EXTERNAL MODULE: ./src/engine.js + 524 modules
-var engine = __webpack_require__(8215);
+// EXTERNAL MODULE: ./src/engine.js + 592 modules
+var engine = __webpack_require__(9408);
 ;// CONCATENATED MODULE: ./src/posture/fix-honesty-gate.js
 // Deterministic honesty gates on fix / finding output (#7).
 //

package/dist/113.index.js

@@ -1,5 +1,5 @@
 export const id = 113;
-export const ids = [113,11];
+export const ids = [113,526];
 export const modules = {
 
 /***/ 4113:
@@ -12,7 +12,7 @@ export const modules = {
 /* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1421);
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6760);
-/* harmony import */ var _fix_verify_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11);
+/* harmony import */ var _fix_verify_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3526);
 // Closed-loop fix verification (v0.68).
 //
 // Existing `fix-verify.js` does scan + lint. This module adds the third
@@ -174,7 +174,7 @@ function _summarize(legs, verdict) {
 
 /***/ }),
 
-/***/ 11:
+/***/ 3526:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -193,8 +193,8 @@ var external_node_child_process_ = __webpack_require__(1421);
 var external_node_fs_ = __webpack_require__(3024);
 // EXTERNAL MODULE: external "node:path"
 var external_node_path_ = __webpack_require__(6760);
-// EXTERNAL MODULE: ./src/engine.js + 524 modules
-var engine = __webpack_require__(8215);
+// EXTERNAL MODULE: ./src/engine.js + 595 modules
+var engine = __webpack_require__(4660);
 ;// CONCATENATED MODULE: ./src/posture/fix-honesty-gate.js
 // Deterministic honesty gates on fix / finding output (#7).
 //
@@ -372,6 +372,155 @@ function gateFixOutput({ residual, verdict, evidence, signals } = {}) {
 
 const _internals = Object.freeze({ BANNED_RESIDUAL_PHRASES, CITATION_RE, FP_VERDICTS });
 
+;// CONCATENATED MODULE: ./src/posture/test-runner.js
+// R5 (partial, roadmap) — the project's own test suite as a verification
+// stage for `verifyFix()` (see `fix-verify.js`). Closes the gap where a
+// "verified" fix only proved a finding's stableId stopped firing — a patch
+// that deletes the feature entirely would satisfy that just as well as a
+// real fix. Running the project's own tests is the cheapest available check
+// that the application still works.
+//
+// Execution-safety note: this spawns the TARGET PROJECT's own test command
+// in the target project's own directory. That is deliberately NOT routed
+// through the R1 confinement sandbox (`../sandbox/`). That sandbox exists to
+// contain untrusted proof-of-concept exploit code the scanner itself
+// synthesizes — code nobody has vetted, being run for the first time. A
+// project's pre-existing test suite is the opposite case: it is the
+// project's own trusted source, already sitting on disk, and running it is
+// exactly what a human developer does by hand before trusting a fix.
+// Wrapping "npm test" / "pytest" / "go test" in the PoC sandbox's
+// syscall/network/filesystem restrictions would break the large majority of
+// real test suites (they bind local ports, spawn child processes, write temp
+// fixtures, etc.) for no corresponding security benefit.
+
+
+
+
+
+const DEFAULT_TIMEOUT_MS = 300_000;
+const NPM_PLACEHOLDER = /Error: no test specified/i;
+
+function _exists(scanRoot, rel) {
+  try { return external_node_fs_.existsSync(external_node_path_.join(scanRoot, rel)); } catch { return false; }
+}
+
+function _isDir(scanRoot, rel) {
+  try { return external_node_fs_.statSync(external_node_path_.join(scanRoot, rel)).isDirectory(); } catch { return false; }
+}
+
+function _binaryAvailable(cmd) {
+  try {
+    const r = (0,external_node_child_process_.spawnSync)(cmd, ['--version'], { timeout: 5_000, stdio: 'ignore' });
+    return !(r.error && r.error.code === 'ENOENT');
+  } catch {
+    return false;
+  }
+}
+
+// Detect the project's test command. Read-only — never spawns the actual
+// test run, only (optionally) a cheap `--version` probe to confirm a tool
+// like `pytest` is actually installed before committing to it. Returns
+// `null` when nothing detectable is found — most scanned repos will hit
+// this path, and that must not be treated as a failure by callers.
+function detectTestCommand(scanRoot) {
+  if (!scanRoot) return null;
+
+  // JS/TS — package.json with a real (non-placeholder) `scripts.test`.
+  let pkg = null;
+  try { pkg = JSON.parse(external_node_fs_.readFileSync(external_node_path_.join(scanRoot, 'package.json'), 'utf8')); } catch { pkg = null; }
+  const testScript = pkg && pkg.scripts && pkg.scripts.test;
+  if (testScript && !NPM_PLACEHOLDER.test(String(testScript))) {
+    if (_exists(scanRoot, 'pnpm-lock.yaml')) return { cmd: 'pnpm', args: ['test'], kind: 'pnpm' };
+    if (_exists(scanRoot, 'yarn.lock')) return { cmd: 'yarn', args: ['test'], kind: 'yarn' };
+    if (_exists(scanRoot, 'bun.lockb') || _exists(scanRoot, 'bun.lock')) return { cmd: 'bun', args: ['test'], kind: 'bun' };
+    return { cmd: 'npm', args: ['test', '--silent'], kind: 'npm' };
+  }
+
+  // Python — pytest.ini / pyproject.toml / tox.ini / a tests/ dir, and the
+  // `pytest` binary actually available. If pytest isn't installed we do NOT
+  // report a python test command — falling through lets a later language
+  // marker (e.g. go.mod in a polyglot repo) still be detected.
+  const pyMarker = _exists(scanRoot, 'pytest.ini') || _exists(scanRoot, 'pyproject.toml') ||
+    _exists(scanRoot, 'tox.ini') || _isDir(scanRoot, 'tests');
+  if (pyMarker && _binaryAvailable('pytest')) {
+    return { cmd: 'pytest', args: ['-q'], kind: 'pytest' };
+  }
+
+  // Go
+  if (_exists(scanRoot, 'go.mod')) {
+    return { cmd: 'go', args: ['test', './...'], kind: 'go' };
+  }
+
+  return null;
+}
+
+// Run the detected test command with a walltime budget. Always returns a
+// result object — never throws. Distinguishes four outcomes:
+//   - no detectable/runnable command  -> status: 'skipped'  (does NOT fail)
+//   - ran and exited 0                -> status: 'passed'
+//   - ran and exited non-zero         -> status: 'failed'
+//   - ran past the timeout budget     -> status: 'failed', timedOut: true
+function runProjectTests(scanRoot, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const startedAt = Date.now();
+  const command = detectTestCommand(scanRoot);
+  if (!command) {
+    return {
+      status: 'skipped', passed: null, skipped: true,
+      reason: 'no-test-command-detected', exitCode: null, timedOut: false,
+      durationMs: Date.now() - startedAt,
+    };
+  }
+
+  let r;
+  try {
+    r = (0,external_node_child_process_.spawnSync)(command.cmd, command.args, {
+      cwd: scanRoot,
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      env: { ...process.env, CI: '1' },
+    });
+  } catch (e) {
+    // The spawn call itself threw (rare — e.g. cwd vanished). Treat as
+    // "could not run", not "ran and failed".
+    return {
+      status: 'skipped', passed: null, skipped: true,
+      reason: `spawn-error: ${e.message}`, exitCode: null, timedOut: false,
+      durationMs: Date.now() - startedAt,
+    };
+  }
+  const durationMs = Date.now() - startedAt;
+
+  if (r.error && r.error.code === 'ENOENT') {
+    // The detected tool isn't actually installed on this machine. Not a
+    // test failure — the suite never ran.
+    return {
+      status: 'skipped', passed: null, skipped: true,
+      reason: `${command.kind}-not-installed`, exitCode: null, timedOut: false, durationMs,
+    };
+  }
+
+  if (r.status === null) {
+    // spawnSync sets status:null both on timeout-kill and on being killed by
+    // another signal; either way the run did not complete, which is a
+    // verification failure, never a skip — we asked for a result and the
+    // process was terminated before producing one.
+    return {
+      status: 'failed', passed: false, skipped: false,
+      reason: 'timed-out', exitCode: null, timedOut: true, durationMs,
+    };
+  }
+
+  return {
+    status: r.status === 0 ? 'passed' : 'failed',
+    passed: r.status === 0,
+    skipped: false,
+    reason: r.status === 0 ? null : 'test-failures',
+    exitCode: r.status,
+    timedOut: false,
+    durationMs,
+  };
+}
+
 ;// CONCATENATED MODULE: ./src/posture/fix-verify.js
 // Closed-loop /fix verification (Sentinel-parity FR-L4-4, FR-L4-5).
 //
@@ -381,6 +530,10 @@ const _internals = Object.freeze({ BANNED_RESIDUAL_PHRASES, CITATION_RE, FP_VERD
 //   1. The original finding's stableId no longer fires on the patched file.
 //   2. No new findings at severity ≥ medium were introduced by the patch.
 //   3. The project's existing linter (when present) passes on the patched file.
+//   4. The project's own test suite (when detectable) still passes. This is
+//      the R5 gap-closer: a patch that silently deletes the feature would
+//      satisfy (1) and (2) just as well as a real fix — only running the
+//      tests catches that. See `test-runner.js` for detection + execution.
 //
 // If any of those fail, the caller is expected to NOT apply the patch and
 // instead surface a "fix plan" — a numbered list of steps the engineer can
@@ -392,6 +545,7 @@ const _internals = Object.freeze({ BANNED_RESIDUAL_PHRASES, CITATION_RE, FP_VERD
 
 
 
+
 const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
 
 // Run a focused re-scan over just the patched file(s) using the in-memory
@@ -494,29 +648,77 @@ function runLinter(cwd, cmd, args) {
 // dishonest or over-claiming fix fails the gate. When `fixMeta` is absent
 // (the deterministic MCP write path, which has no claims to check) the honesty
 // gate is skipped and behavior is unchanged.
+// R5 (partial) — the test-suite stage. Runs the target project's own tests,
+// in the target project's own directory, against whatever is currently on
+// disk there. See `test-runner.js`'s header comment for why that run is
+// deliberately NOT routed through the R1 PoC-confinement sandbox: this is
+// the project's own already-trusted suite, not untrusted synthesized code.
+//
+// Caveat that matters for callers: `verifyPatch` above re-scans the
+// candidate patch purely in memory (no write to disk), but a test runner
+// needs real files — there is no cheap way to hand a runner an in-memory
+// overlay. So this leg reports on the CURRENT on-disk tree, not the
+// candidate `files` map, when `verifyFix` is used as a pre-write preview
+// (e.g. the `verify_fix` MCP tool). Callers that apply the patch first and
+// then re-verify get the strongest signal; that ordering is not enforced
+// here — it's the caller's responsibility, same as it already is for the
+// closed-loop `fix-verify-loop.js` path.
+// Does the caller's candidate patch differ from what is on disk right now?
+// If so, any test run necessarily exercised the pre-patch tree. Compared by
+// content so a patch that happens to match disk (already applied) is correctly
+// treated as NOT pre-patch.
+function _candidateDiffersFromDisk(scanRoot, files) {
+  if (!files || typeof files !== 'object') return false;
+  for (const [rel, content] of Object.entries(files)) {
+    if (typeof content !== 'string') continue;
+    try {
+      const abs = external_node_path_.resolve(scanRoot, rel);
+      if (external_node_fs_.readFileSync(abs, 'utf8') !== content) return true;
+    } catch {
+      return true; // candidate file absent on disk -> definitely not applied
+    }
+  }
+  return false;
+}
+
 async function verifyFix({
   scanRoot,
   originalFindingStableId,
   files,
   depFileContents,
   fixMeta,
+  testTimeoutMs,
 } = {}) {
   const rescan = await verifyPatch({ scanRoot, originalFindingStableId, files, depFileContents });
   const lint = runProjectLinter(scanRoot, Object.keys(files || {}));
+  const tests = runProjectTests(scanRoot, testTimeoutMs != null ? { timeoutMs: testTimeoutMs } : {});
+  // True when a candidate patch was supplied but has not been written, so the
+  // suite necessarily ran against the pre-patch tree. Surfaced in the summary
+  // and on the result so a caller cannot mistake it for a verified patch.
+  const _testedPrePatch = !tests.skipped && _candidateDiffersFromDisk(scanRoot, files);
+  const testsOk = tests.skipped ? true : tests.passed === true;
   let honesty = null;
   if (fixMeta && typeof fixMeta === 'object') {
     try { honesty = gateFixOutput(fixMeta); } catch { honesty = null; }
   }
-  const ok = rescan.ok && (lint.ok || lint.skipped) && (honesty ? honesty.ok : true);
+  const ok = rescan.ok && (lint.ok || lint.skipped) && testsOk && (honesty ? honesty.ok : true);
   const summary = [
     `re-scan: ${rescan.ok ? 'PASS' : 'FAIL — ' + rescan.reason}`,
     `linter:  ${lint.runner === 'none' ? 'skipped (no linter config)'
               : lint.skipped ? `${lint.runner} not installed`
               : lint.ok ? `${lint.runner} PASS`
               : `${lint.runner} FAIL (exit ${lint.exitCode})`}`,
+    // Say which tree the suite actually ran against. `files` is a candidate
+    // patch held in memory; the runner needs real files, so it sees whatever is
+    // on disk. Reporting a bare "PASS" here would let a caller believe the
+    // PATCH passed the tests when the suite may have run on unpatched code.
+    `tests:   ${tests.skipped ? `skipped (${tests.reason})`
+              : tests.timedOut ? 'FAIL (timed out)'
+              : tests.passed ? `PASS${_testedPrePatch ? ' — on the CURRENT on-disk tree, NOT the candidate patch' : ''}`
+              : `FAIL (exit ${tests.exitCode})`}`,
     honesty ? `honesty: ${honesty.ok ? `PASS (${honesty.tier})` : 'FAIL — ' + honesty.violations.join('; ')}` : null,
   ].filter(Boolean).join('\n');
-  return { ok, rescan, lint, honesty, summary };
+  return { ok, rescan, lint, tests, testedPrePatch: _testedPrePatch, honesty, summary };
 }
 
 

package/dist/178.index.js

@@ -13,7 +13,7 @@ export const modules = {
 /* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1421);
 /* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3024);
 /* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6760);
-/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8215);
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4660);
 // Time-travel + counterfactual scanning (v0.68).
 //
 // Two new modes that exploit the pure-input shape of runFullScan: