seathatflowsinourveins · Sep 30, 2026 · Sep 30, 2026 · Sep 30, 2026
@@ -773,7 +773,7 @@ blanks before a heredoc operator (`A=$(( 1 + 2 )) bash <<EOF`); a data heredoc w
 paren-free substitutions with its regular expression (`$(curl $(date))` misses the outer `curl`); a newline read as a
 blank in `bash` newline `-c "x"`; and a heredoc that a quote or `"$( )"` carries over lines has its head on an earlier
 line, so its heredoc reads as a possible fetch. The text scanners read in linear time (a run of 64,000 unclosed `((`
-takes under 150 ms and at most 2.5 times longer per doubling: `test-child-usage.mjs`), and so does the reading of the lanes (below, "What the parser costs"). The repeated reading is cheap and
+takes under 150 ms, and its time plus 5 ms at 64,000 stays under 8 times that at 16,000: `test-child-usage.mjs`), and so does the reading of the lanes (below, "What the parser costs"). The repeated reading is cheap and
 is not cached: over this host's 136,361 distinct real commands `measureTranscript` of one Bash call took 44 s in all
 (mean 0.32 ms, p99 1.2 ms, at most 10.9 ms), of which `executedText` is 0.07 ms plain and 0.09 ms with inline HTTP,
 `fetchKind` 0.08 ms and `commandInvocations` 0.13 ms (`evidence/artifacts/pra-u1-differential-20260929/timing.mjs`).

@@ -1,7 +1,7 @@
 ca62177687420fe22e03d0510a18e4f32b5d150e0156f6651c48367c3da506e1  check-syntax.mjs
 3e5189342734135e88a2295c1c2152275d9e26c0c7731ed5cbc8905bbccd98a4  child-usage.mjs
 cd303779df6521c804070a319aa04c86ed2d6fe1c099c537836f037dec5f4e8b  codex-cross-review.mjs
-b5ba8b1601bdad0998d672f90e60ee59fd2ba3bdc82716874532efce320e0dce  test-child-usage.mjs
+4f45b0f613d9d73fbd75792ed6a9b2cfad50ab98d3e3dcd54cd6b53791e32674  test-child-usage.mjs
 2617c081f606268ed20a6e00f6472495fad950db433ca3afbb44ea970aaac446  test-codex-envelope.mjs
 cfc4908cea1f53da4e269a10cb5ebb6a4311f9bc477e61c62e245452719eede3  test-contract-mutations.mjs
 6a71109f5021e65d5be6cf1ca9d7b765eda6a5d175cbde3cff662a996f99825d  test-envelope.mjs

@@ -500,20 +500,34 @@ const deepRun = timed(() => { try { return ['"$('.repeat(3000), Array.from({ len
 expect('nesting: 3,000 nested "$( and a 3,000-deep shell heredoc chain are read without exhausting the stack', Array.isArray(deepRun.r) && deepRun.ms < 1000)
 // D8 (GPT-6 #9, Claude review R9): the M4 text scanners read a run of unclosed "((" in linear time. Before the repair each
 // unclosed "((" looked ahead to the end of its line, so n = 8000, 16000 and 32000 took about 315, 1100 and 5000 ms (four times
-// per doubling). Each size is timed as the best of five runs; a run over 1.5 s ends the doubling (it is far past the bound
-// already), and 5 ms of the allowance is timer and GC noise, not growth. The brief's requirement, at most 2.5 times per doubling and
-// under 150 ms at 64,000, applies to that input (about 30 ms here); the other shapes below keep the ratio and take an absolute
-// bound of 1.5 s at 64,000, since each does real work per unit and a CI runner is slower than this host.
+// per doubling). Each size is timed as the best of five runs (the minimum of repeats: CPython's timeit documents that the lowest value
+// bounds what the machine can do and the higher ones come from other processes, Doc/library/timeit.rst at 3.13); a run over 1.5 s
+// ends the doubling (it is far past the bound already).
+// Scaling criterion (2026-09-30; it replaces "each size at most 2.5 times the last plus 5 ms", which the brief asked for per doubling):
+// the growth exponent from 16000 to 64000, ln((t64 + 5 ms) / (t16 + 5 ms)) / ln 4, stays under 1.5 (1 is linear, 2 is quadratic, 1.5 is
+// where they meet on a log scale). The 5 ms is the timer and GC noise the earlier check allowed; the 8000 and 32000 times are measured and
+// printed but carry no weight, because judging every step on its own is what failed validate-macos on #548 (twice) and #552 at steps of
+// 2.56 to 3.0 times on linear scanners (actions runs 36745793168, attempts 1 and 2, and 36751526079, full-suite-macos.log); all 36 samples
+// of those runs have an exponent of 1.19 or less. This is a local check: google/benchmark also judges complexity over a family of sizes,
+// but it fits fixed curves and picks the lowest normalized RMS (docs/user_guide.md "Calculating Asymptotic Complexity (Big O)",
+// src/complexity.cc MinimalLeastSq, v1.9.5) and needs its C++ harness.
+// Detection floor: a pure quadratic scan passes while its time at 16,000 is under 4.4 ms (under 70 ms at 64,000; the old ratio failed it
+// above 13 ms), so for small scans the absolute bounds are the guard: the brief's 150 ms at 64,000 for '((' (about 30 ms here) and 1.5 s
+// for the other shapes, since each does real work per unit and a CI runner is slower than this host. The controls below keep a quadratic
+// scan above that floor failing.
 {
-  const ratio = (ms) => ms.length === 4 && ms.every((t, i) => i === 0 || t <= 2.5 * ms[i - 1] + 5)
-  // Best of five per size; when the ratio fails, up to two more rounds and the elementwise minimum of all rounds, so one pause
+  const SIZES = [8000, 16000, 32000, 64000]
+  // The growth exponent from 16000 to 64000 (a 4 times range): ln((t64 + 5 ms) / (t16 + 5 ms)) / ln 4.
+  const exponent = (ms) => Math.log((ms[3] + 5) / (ms[1] + 5)) / Math.log(SIZES[3] / SIZES[1])
+  const scales = (ms) => ms.length === 4 && exponent(ms) < 1.5
+  // Best of five per size; when the criterion fails, up to two more rounds and the elementwise minimum of all rounds, so one pause
   // (a GC or a busy runner) cannot fail a linear scan, while a quadratic one fails every round.
-  const doubling = (make, run) => {
+  const doubling = (make, run, rounds = 3) => {
     run(make(2000)); run(make(2000)) // warm-up
     let best = []
-    for (let round = 0; round < 3 && !ratio(best); round++) {
+    for (let round = 0; round < rounds && !scales(best); round++) {
       const ms = []
-      for (const n of [8000, 16000, 32000, 64000]) {
+      for (const n of SIZES) {
         const input = make(n)
         let t = Infinity
         for (let i = 0; i < 5; i++) { t = Math.min(t, timed(() => run(input)).ms); if (t > 1500) break }
@@ -524,12 +538,21 @@ expect('nesting: 3,000 nested "$( and a 3,000-deep shell heredoc chain are read
     }
     return best
   }
-  const linear = (ms) => ratio(ms) && ms[3] < 150 // the brief's bound, for '(('.repeat(n) + 'qmd'
-  const linearWork = (ms) => ratio(ms) && ms[3] < 1500 // every other shape
+  const linear = (ms) => scales(ms) && ms[3] < 150 // the brief's bound, for '(('.repeat(n) + 'qmd'
+  const linearWork = (ms) => scales(ms) && ms[3] < 1500 // every other shape
   const shape = (label, make, reader, run, bound = linearWork) => {
     const ms = doubling(make, run)
-    expect('linear: ' + label + ' (' + reader + ') at n = 8000, 16000, 32000, 64000 takes [' + ms.map((t) => t.toFixed(0)).join(', ') + '] ms', bound(ms))
+    expect('linear: ' + label + ' (' + reader + ') at n = 8000, 16000, 32000, 64000 takes [' + ms.map((t) => t.toFixed(0)).join(', ') + '] ms, exponent ' + (ms.length === 4 ? exponent(ms).toFixed(2) : 'n/a'), bound(ms))
   }
+  // Controls of the criterion. (1) Recorded samples (validate-macos, 2026-09-30): four linear scans that the per-doubling check failed or came
+  // near failing pass, and the scan measured before the repair, continued quadratically, fails. (2) A scan that is quadratic by construction,
+  // timed by the same harness in one round (a harness whose times were all near zero would pass anything): it is refused while its time at
+  // 16,000 is at least 4.4 ms, or when the 1.5 s cap ends its doubling early; from this host's times, a host about 5 times faster would
+  // miss it and one about 16 times slower would end it early.
+  expect('linear: control: recorded macOS samples of linear scans that failed or came near failing the per-doubling check fit an exponent under 1.5', [[9, 16, 48, 104], [7, 17, 47, 84], [55, 103, 203, 519], [3, 6, 18, 48]].every((ms) => scales(ms)))
+  expect('linear: control: the scan measured before the repair (315, 1100, 5000 ms), continued quadratically, fits an exponent over 1.5', !scales([315, 1100, 5000, 20000]))
+  const quadraticMs = doubling((n) => 'x'.repeat(n), (c) => { let s = 0; for (let i = 0; i < c.length; i++) for (let j = 0; j < c.length / 8; j++) s += j; return s }, 1)
+  expect('linear: control: a scan that is quadratic by construction takes [' + quadraticMs.map((t) => t.toFixed(0)).join(', ') + '] ms, exponent ' + (quadraticMs.length === 4 ? exponent(quadraticMs).toFixed(2) : 'n/a') + ', and is refused', !scales(quadraticMs))
   const dparen = (n) => '(('.repeat(n) + 'qmd'
   shape('a run of unclosed ((', dparen, 'executedText', (c) => executedText(c), linear)
   shape('a run of unclosed ((', dparen, 'executedText inlineHttp', (c) => executedText(c, { inlineHttp: true }), linear)

@@ -44165,12 +44165,12 @@
     },
     {
       "path": "examples/claude-native/workflows/README.md",
-      "sha256": "8ffcf5045f19dbd48566f66b818964cc564c6f68a9ed13481c0e6b3470ad528a",
-      "bytes": 107673
+      "sha256": "b25e7d3f2639a54a8a6114c2ca316e8a4121fd85e583793481321765b35f425e",
+      "bytes": 107700
     },
     {
       "path": "examples/claude-native/workflows/SHA256SUMS",
-      "sha256": "d79b44eb8afe4f536dcf23c1bec0814d8abc1c51e27a84c6c7524b37eb2f5e76",
+      "sha256": "575ea29e9173bbfc05d1c44f0c7397d84b9eae0cc08c2e5218fb3cb222ce92b4",
       "bytes": 1217
     },
     {
@@ -44210,8 +44210,8 @@
     },
     {
       "path": "examples/claude-native/workflows/test-child-usage.mjs",
-      "sha256": "b5ba8b1601bdad0998d672f90e60ee59fd2ba3bdc82716874532efce320e0dce",
-      "bytes": 114280
+      "sha256": "4f45b0f613d9d73fbd75792ed6a9b2cfad50ab98d3e3dcd54cd6b53791e32674",
+      "bytes": 117347
     },
     {
       "path": "examples/claude-native/workflows/test-codex-envelope.mjs",