[joelteply]

Two changes to source-hygiene.

1. Every ratchet now scans all production code. production_half stopped at the first #[cfg(test)] anywhere in a file, so an indented test helper inside an impl ended "production" for the rest of the file. In cognition/llm_deliberation_faculty.rs that hid about 9,000 lines from every ratchet except derived_bounds, which already carried its own column-zero split. There is now one split, at column zero, for every rule.

Baselines are re-measured to what was always there; this is not new debt:

Ratchet	Old baseline	Real count
unwraps	2,119	2,274
serialization	234	245
spawn sites	123	128
hand-built homes	72	79

2. head_cuts ratchet (179 sites when measured, 2026-10-20). On prompt paths it counts cuts that keep the head of text or shrink it by a literal: chars().take, head_to_tokens, first-line-only, [..N], literal take/truncate, and min/clamp ceilings next to a size word. These drop the newest end, so the mind acts as if time never moved. A cut that never reaches a prompt opts out with head-cut-ok: <why>.

The file splits (#5224, #5225, #5226 and the sweep) are measured against these true baselines, so this should land before them.

🤖 Generated with Claude Code

[joelteply]

Review #5227 exact head 24f51e7 against canary, 2026-10-20 18:49 UTC.

[P1] Isolate the advertised hygiene change before landing. The actual PR diff includes context epoch/render behavior, request checkpoint logic, generated request protocol changes, and LLAMA_CPP_PIN 50b02b8 -> 76a1d605 (plus submodule update). This is not a hygiene-only prerequisite or pure move. Landing in the requested prerequisite order also lands those serving/context changes without their separate acceptance. Rebase/cherry-pick the intended hygiene commits onto current canary, or explicitly declare and independently validate the expanded scope; do not approve the narrow title as the full diff.

[P2] production_half still does not scan all production code. In core/source-hygiene/src/lib.rs it stops at any column-zero #[cfg(test)], including a top-level test helper followed by production functions. An indented inner #![cfg(test)] also still terminates the whole enclosing file. Column zero fixes the observed impl helper but is not item scope. Add fixtures with a gated top-level helper followed by production and a nested test module with an inner attribute, and preserve following production when excluding test items. Documentation saying it errs only toward noise is false for these valid Rust shapes.

Validation: read exact-head GitHub file patches and full PR changed-file inventory; no compilation, runtime mutation or claimed live regression. Existing #5221 bcedd84 gate finding remains unchanged: failed diff producer can exit success. No full approval.

[joelteply]

Exact head 2fe46c2: previous stacked epoch/engine scope finding is resolved (eight source-hygiene files only).

[P2] Shared production projection still hides actual production. Independent review found a concrete unchanged consumer: cognition/deliberation_prompt.rs:259 gates only test helper compose with a column-zero #[cfg(test)]. Production stable_blocks, volatile_blocks and helpers follow it; the real test module starts at546. production_half truncates all of them. Fix item-range exclusion and resume scanning afterward, retaining original line coordinates; extend coverage to a top-level test helper followed by violating production and production following a test module. The indented-helper fixture does not cover this. The new claim that the projection never hides production is false.

Independent source replay substantiates layer baseline253 file/module pairs ->674 line/module pairs across73 module pairs, and head-cut baseline179 on unchanged base. Other baselines not independently reproduced here. Per-line metric is a textual-reference ratchet: two qualified refs on one line or replacing refs with an import changes counts without changing coupling. Describe that limit; it is not architectural coupling proof by itself.

No builds/runtime changes. Scoped hold remains for shared production projection; scope cleanup and the two replayed baseline values pass.

[joelteply]

Independent source review of bcbab21: the concrete deliberation_prompt compose-helper defect is fixed and subsequent production retains its original line coordinates. Two remaining valid-source counterexamples still hide production:

[P2] Same-line gated item (lib.rs:233): #[cfg(test)] fn helper() {} followed by fn production() { value.unwrap(); }. Starting at i+1 skips the actual gated item and blanks the following production function. Scan the remainder of the attribute's line.

[P2] Comment punctuation after closing brace (lib.rs:325-327): a gated module ending } // fixture ends; production follows followed by a production function. rest.contains(';') treats the comment semicolon as structural continuation, so scanning consumes the next item. Only lexed structural tokens should determine item continuation.

Extend existing tests with both cases, checking retained production and original line number. These are source-traced counterexamples, not compiled test receipts. Update stale SourceFile::production truncation wording and avoid claiming textual per-line coupling count is invariant under formatting/import regrouping. No builds or runtime changes; scoped hold remains.

[joelteply]

Concrete candidate for the three reviewed scanner cases on exact bcbab21. Prepared outside your checkout; no baseline edits. Exact-base apply check and parse-only rustfmt pass; Rust fixtures have NOT been executed. This is a proposed patch for owner review/integration, not approval of the PR. Independent candidate review is underway.

Extends existing fixtures for same-line gated declarations, trailing-comment semicolon, real constructor closing syntax and restricted visibility. It retains the existing approximate projector: multiple items/attributes on one physical line and arbitrary nested block comments are not covered. Re-run affected fixtures and full hygiene on the authorized compiler, investigating measured totals before changing baselines.

--- a/core/source-hygiene/src/lib.rs
+++ b/core/source-hygiene/src/lib.rs
@@ -230,7 +230,11 @@
             i += 1;
             continue;
         }
-        let end = gated_item_end(&lines, i + 1);
+        // The gated item can begin on the attribute's own line. Keep the slice's
+        // line count intact so blanking still preserves source line numbers.
+        let mut item_lines = lines[i..].to_vec();
+        item_lines[0] = &lines[i]["#[cfg(test)]".len()..];
+        let end = i + gated_item_end(&item_lines, 0);
         out.extend(std::iter::repeat_n("", end + 1 - i));
         gated = true;
         i = end + 1;
@@ -324,7 +328,11 @@
                 depth = depth.saturating_sub(1);
                 // `};` / `});` closes the item on this line too; the `;` arm takes it.
                 let rest = text[i + 1..].split('\n').next().unwrap_or(""); // unwrap_or: split always yields one piece
-                if depth == 0 && opened && !rest.contains(';') {
+                let rest = split_code_and_comment(rest).0.trim_start();
+                // Only immediate closing syntax continues this item. Punctuation in
+                // a trailing comment or a later statement cannot extend its lifetime.
+                let continues = matches!(rest.as_bytes().first(), Some(b';' | b')' | b']'));
+                if depth == 0 && opened && !continues {
                     return line;
                 }
             }
@@ -717,6 +725,18 @@
         assert_eq!(p.lines().count(), 5, "line numbers stay true");
         let helper = "fn real() {}\n#[cfg(test)]\nfn helper() {\n    q.unwrap();\n}\nfn more() {}\n";
         assert_eq!(production_half(helper), "fn real() {}\n\n\n\n\nfn more() {}");
+        // Regression for #5227: a same-line test item must not consume its successor.
+        let inline = "#[cfg(test)] mod tests {}\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(inline), "\nfn real() { x.unwrap(); }");
+        let inline_decl = "#[cfg(test)] mod tests;\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(inline_decl), "\nfn real() { x.unwrap(); }");
+        // A comment's semicolon cannot make the closed test module swallow production.
+        let commented = "#[cfg(test)]\nmod tests {\n} // diagnostic; not syntax\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(commented), "\n\n\nfn real() { x.unwrap(); }");
+        // Real constructor closing syntax still belongs to the gated static.
+        let constructor = "#[cfg(test)]\nstatic X: LazyLock<()> = LazyLock::new(|| {\n});\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(constructor), "\n\n\nfn real() { x.unwrap(); }");
+
     }
 
     /// What this catches: the production/test split silently swallowing the whole
--- a/core/source-hygiene/src/derived_bounds.rs
+++ b/core/source-hygiene/src/derived_bounds.rs
@@ -111,14 +111,6 @@
     "u8", "u16", "u32", "usize", "u64", "i32", "i64", "f32", "f64",
 ];
 
-/// Const declaration prefixes, longest first so `pub const` is not read as `const`.
-const CONST_PREFIXES: &[&str] = &[
-    "pub(crate) const ",
-    "pub(super) const ",
-    "pub const ",
-    "const ",
-];
-
 pub struct DerivedBounds;
 
 impl DerivedBounds {
@@ -188,9 +180,16 @@
     /// `(name, type, value)` if this line declares a numeric constant.
     fn const_declaration<'a>(code: &'a str) -> Option<(&'a str, &'a str, &'a str)> {
         let trimmed = code.trim_start();
-        let rest = CONST_PREFIXES
-            .iter()
-            .find_map(|p| trimmed.strip_prefix(*p))?;
+        // Visibility does not change whether a declaration is a numeric constant.
+        // Restricted visibility includes pub(in crate::owner), not only crate/super.
+        let declaration = if let Some(restricted) = trimmed.strip_prefix("pub(") {
+            restricted.split_once(')')?.1.trim_start()
+        } else if let Some(public) = trimmed.strip_prefix("pub ") {
+            public.trim_start()
+        } else {
+            trimmed
+        };
+        let rest = declaration.strip_prefix("const ")?;
         let (name, tail) = rest.split_once(':')?;
         let (ty, value) = tail.split_once('=')?;
         let ty = ty.trim();
@@ -410,6 +409,11 @@
         assert_eq!(DerivedBounds.check(&mk("let c = A_SECONDS * B_TOKENS_PER_S;")).len(), 1);
         // A live-path bound with a bare literal and nothing said about it.
         assert_eq!(DerivedBounds.check(&mk("const FILL_CAP_TOKENS: usize = 15_000;")).len(), 1);
+        // Regression for #5227: restricting visibility must not hide the same bound.
+        for visibility in ["pub", "pub(crate)", "pub(super)", "pub(self)", "pub(in crate::owner)"] {
+            let raw = format!("{visibility} const FILL_CAP_TOKENS: usize = 15_000;");
+            assert_eq!(DerivedBounds.check(&mk(&raw)).len(), 1, "{visibility}");
+        }
         // The same, derived from a measurement or another named bound: fine.
         assert!(DerivedBounds
             .check(&mk("const FILL_CAP_TOKENS: usize = BOOTSTRAP_WORKING_SET as usize;"))

[joelteply]

HOLD candidate comment6303540448: independent review found the closing-brace punctuation allowlist can stop early in valid gated static initializers ({1} + { let y = 2; ... } or method-call continuation), leaking test code into production. Do not integrate that hunk. Same-line attribute and restricted-visibility changes have no finding so far. Revision is being prepared to distinguish semicolon-terminated items and track structural delimiters, with both counterexamples added to existing fixtures. No compiled validation claimed.

[joelteply]

Separately reviewed scoped patch against bcbab21: same-line cfg(test) handling and restricted const visibility, with existing-fixture additions. Independent Astra source approval plus parent exact-content check; apply check passes. No compilation claimed. This deliberately excludes the held closing-item repair. Run fixtures/full hygiene and remeasure on the authorized compiler before promotion. Do not use prior full candidate.

--- a/core/source-hygiene/src/lib.rs
+++ b/core/source-hygiene/src/lib.rs
@@ -230,7 +230,11 @@
             i += 1;
             continue;
         }
-        let end = gated_item_end(&lines, i + 1);
+        // The gated item can begin on the attribute's own line. Keep the slice's
+        // line count intact so blanking still preserves source line numbers.
+        let mut item_lines = lines[i..].to_vec();
+        item_lines[0] = &lines[i]["#[cfg(test)]".len()..];
+        let end = i + gated_item_end(&item_lines, 0);
         out.extend(std::iter::repeat_n("", end + 1 - i));
         gated = true;
         i = end + 1;
@@ -717,6 +721,12 @@
         assert_eq!(p.lines().count(), 5, "line numbers stay true");
         let helper = "fn real() {}\n#[cfg(test)]\nfn helper() {\n    q.unwrap();\n}\nfn more() {}\n";
         assert_eq!(production_half(helper), "fn real() {}\n\n\n\n\nfn more() {}");
+        // Regression for #5227: a same-line test item must not consume its successor.
+        let inline = "#[cfg(test)] mod tests {}\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(inline), "\nfn real() { x.unwrap(); }");
+        let inline_decl = "#[cfg(test)] mod tests;\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(inline_decl), "\nfn real() { x.unwrap(); }");
+
     }
 
     /// What this catches: the production/test split silently swallowing the whole
--- a/core/source-hygiene/src/derived_bounds.rs
+++ b/core/source-hygiene/src/derived_bounds.rs
@@ -111,14 +111,6 @@
     "u8", "u16", "u32", "usize", "u64", "i32", "i64", "f32", "f64",
 ];
 
-/// Const declaration prefixes, longest first so `pub const` is not read as `const`.
-const CONST_PREFIXES: &[&str] = &[
-    "pub(crate) const ",
-    "pub(super) const ",
-    "pub const ",
-    "const ",
-];
-
 pub struct DerivedBounds;
 
 impl DerivedBounds {
@@ -188,9 +180,16 @@
     /// `(name, type, value)` if this line declares a numeric constant.
     fn const_declaration<'a>(code: &'a str) -> Option<(&'a str, &'a str, &'a str)> {
         let trimmed = code.trim_start();
-        let rest = CONST_PREFIXES
-            .iter()
-            .find_map(|p| trimmed.strip_prefix(*p))?;
+        // Visibility does not change whether a declaration is a numeric constant.
+        // Restricted visibility includes pub(in crate::owner), not only crate/super.
+        let declaration = if let Some(restricted) = trimmed.strip_prefix("pub(") {
+            restricted.split_once(')')?.1.trim_start()
+        } else if let Some(public) = trimmed.strip_prefix("pub ") {
+            public.trim_start()
+        } else {
+            trimmed
+        };
+        let rest = declaration.strip_prefix("const ")?;
         let (name, tail) = rest.split_once(':')?;
         let (ty, value) = tail.split_once('=')?;
         let ty = ty.trim();
@@ -410,6 +409,11 @@
         assert_eq!(DerivedBounds.check(&mk("let c = A_SECONDS * B_TOKENS_PER_S;")).len(), 1);
         // A live-path bound with a bare literal and nothing said about it.
         assert_eq!(DerivedBounds.check(&mk("const FILL_CAP_TOKENS: usize = 15_000;")).len(), 1);
+        // Regression for #5227: restricting visibility must not hide the same bound.
+        for visibility in ["pub", "pub(crate)", "pub(super)", "pub(self)", "pub(in crate::owner)"] {
+            let raw = format!("{visibility} const FILL_CAP_TOKENS: usize = 15_000;");
+            assert_eq!(DerivedBounds.check(&mk(&raw)).len(), 1, "{visibility}");
+        }
         // The same, derived from a measurement or another named bound: fine.
         assert!(DerivedBounds
             .check(&mk("const FILL_CAP_TOKENS: usize = BOOTSTRAP_WORKING_SET as usize;"))

[joelteply]

Replacement full candidate, revision 5, against exact bcbab21. Supersedes the HELD original candidate6303540448; safe.patch6303848883 is a subset, do not apply both. Independent Astra source review approves this frozen SHA ce579e35aff9b5ebd98db15e644ddbed2be96682cf7ee5c35bea5bebcfcc1159 after resolving every reported regression. Parent checked source. Same-line cfg, restricted const visibility, item termination and shared nested-comment parsing are covered by existing-fixture extensions, including source-line preservation. Exact-base applicability and syntax parsing pass. NO compiled test execution claimed; run affected fixtures/full hygiene and remeasure on the authorized compiler before promotion. No baseline edits. Existing line-based projection limitations remain; this is not a complete Rust parser.

--- a/core/source-hygiene/src/lib.rs
+++ b/core/source-hygiene/src/lib.rs
@@ -230,7 +230,11 @@
             i += 1;
             continue;
         }
-        let end = gated_item_end(&lines, i + 1);
+        // The gated item can begin on the attribute's own line. Keep the slice's
+        // line count intact so blanking still preserves source line numbers.
+        let mut item_lines = lines[i..].to_vec();
+        item_lines[0] = &lines[i]["#[cfg(test)]".len()..];
+        let end = i + gated_item_end(&item_lines, 0);
         out.extend(std::iter::repeat_n("", end + 1 - i));
         gated = true;
         i = end + 1;
@@ -242,6 +246,51 @@
         out.pop();
     }
     out.join("\n")
+}
+
+/// Byte offset after a block comment's closing delimiter, given its body (after `/*`).
+/// Rust block comments nest; punctuation inside every nesting level is trivia.
+fn block_comment_end(bytes: &[u8]) -> Option<usize> {
+    let (mut depth, mut at) = (1usize, 0usize);
+    while at < bytes.len() {
+        if bytes[at..].starts_with(b"/*") {
+            depth += 1;
+            at += 2;
+        } else if bytes[at..].starts_with(b"*/") {
+            depth -= 1;
+            at += 2;
+            if depth == 0 { return Some(at); }
+        } else {
+            at += 1;
+        }
+    }
+    None
+}
+
+/// Skip Rust whitespace and comments. Comments are trivia even
+/// between `const` and `fn`; nested block comments are consumed as one comment.
+fn skip_item_trivia(mut src: &str) -> &str {
+    loop {
+        src = src.trim_start();
+        if let Some(comment) = src.strip_prefix("//") {
+            match comment.find('\n') {
+                Some(end) => src = &comment[end + 1..],
+                None => return "",
+            }
+        } else if let Some(comment) = src.strip_prefix("/*") {
+            let Some(end) = block_comment_end(comment.as_bytes()) else { return "" };
+            src = &comment[end..];
+        } else {
+            break;
+        }
+    }
+    src
+}
+
+fn significant_word(src: &str) -> (Option<&str>, &str) {
+    let src = skip_item_trivia(src);
+    let end = src.bytes().take_while(|b| b.is_ascii_alphanumeric() || *b == b'_').count();
+    if end == 0 { (None, src) } else { (Some(&src[..end]), &src[end..]) }
 }
 
 /// Index of the last line of the item starting at or after `from` (attributes, blank
@@ -260,9 +309,36 @@
         return last;
     };
     let text = lines[head..].join("\n");
+    // Initializer blocks can be followed by operators, method calls, or more blocks.
+    // A static/const ends at its outer semicolon, never at an initializer's `}`.
+    let (mut keyword, mut rest) = significant_word(&text);
+    if keyword == Some("pub") {
+        rest = skip_item_trivia(rest);
+        if let Some(restricted) = rest.strip_prefix('(') {
+            rest = restricted;
+            loop {
+                rest = skip_item_trivia(rest);
+                match rest.chars().next() {
+                    Some(')') => {
+                        rest = &rest[1..];
+                        break;
+                    }
+                    Some(ch) => rest = &rest[ch.len_utf8()..],
+                    None => return last,
+                }
+            }
+        }
+        (keyword, rest) = significant_word(rest);
+    }
+    let semicolon_terminated = match keyword {
+        Some("static") => true,
+        Some("const") => !matches!(significant_word(rest).0, Some("fn" | "unsafe" | "extern")),
+        _ => false,
+    };
     let b = text.as_bytes();
     let ident = |at: usize| b[at].is_ascii_alphanumeric() || b[at] == b'_';
     let (mut depth, mut line, mut i, mut opened) = (0usize, head, 0usize, false);
+    let (mut parentheses, mut brackets) = (0usize, 0usize);
     while i < b.len() {
         match b[i] {
             b'\n' => line += 1,
@@ -272,12 +348,10 @@
                 }
             }
             b'/' if b.get(i + 1) == Some(&b'*') => {
-                i += 2;
-                while i + 1 < b.len() && !(b[i] == b'*' && b[i + 1] == b'/') {
-                    line += usize::from(b[i] == b'\n');
-                    i += 1;
-                }
-                i += 1;
+                let start = i + 2;
+                let Some(length) = block_comment_end(&b[start..]) else { return last };
+                line += b[start..start + length].iter().filter(|&&c| c == b'\n').count();
+                i = start + length - 1;
             }
             // A raw string, r"…" / r#"…"# / br#"…"#: no escapes, ends at `"` + the same hashes.
             b'r' if (i == 0 || !ident(i - 1)) || (b[i - 1] == b'b' && (i < 2 || !ident(i - 2))) => {
@@ -322,13 +396,17 @@
             }
             b'}' => {
                 depth = depth.saturating_sub(1);
-                // `};` / `});` closes the item on this line too; the `;` arm takes it.
-                let rest = text[i + 1..].split('\n').next().unwrap_or(""); // unwrap_or: split always yields one piece
-                if depth == 0 && opened && !rest.contains(';') {
+                if depth == 0 && parentheses == 0 && brackets == 0
+                    && opened && !semicolon_terminated
+                {
                     return line;
                 }
             }
-            b';' if depth == 0 => return line,
+            b'(' => parentheses += 1,
+            b')' => parentheses = parentheses.saturating_sub(1),
+            b'[' => brackets += 1,
+            b']' => brackets = brackets.saturating_sub(1),
+            b';' if depth == 0 && parentheses == 0 && brackets == 0 => return line,
             _ => {}
         }
         i += 1;
@@ -717,6 +795,55 @@
         assert_eq!(p.lines().count(), 5, "line numbers stay true");
         let helper = "fn real() {}\n#[cfg(test)]\nfn helper() {\n    q.unwrap();\n}\nfn more() {}\n";
         assert_eq!(production_half(helper), "fn real() {}\n\n\n\n\nfn more() {}");
+        // Regression for #5227: a same-line test item must not consume its successor.
+        let inline = "#[cfg(test)] mod tests {}\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(inline), "\nfn real() { x.unwrap(); }");
+        let inline_decl = "#[cfg(test)] mod tests;\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(inline_decl), "\nfn real() { x.unwrap(); }");
+        // A comment's semicolon cannot make the closed test module swallow production.
+        let commented = "#[cfg(test)]\nmod tests {\n} // diagnostic; not syntax\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(commented), "\n\n\nfn real() { x.unwrap(); }");
+        // Real constructor closing syntax still belongs to the gated static.
+        let constructor = "#[cfg(test)]\nstatic X: LazyLock<()> = LazyLock::new(|| {\n});\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(constructor), "\n\n\nfn real() { x.unwrap(); }");
+        // Regression for the first proposed fix: initializer blocks do not end a static.
+        for initializer in [
+            "{1} + { let y = 2;\n const EXTRA_LIMIT: usize = 9;\n y + EXTRA_LIMIT\n}",
+            "{1usize}.wrapping_add({ let y = 2;\n const EXTRA_LIMIT: usize = 9;\n y + EXTRA_LIMIT\n})",
+            "[ { let y = 2;\n const EXTRA_LIMIT: usize = 9;\n y + EXTRA_LIMIT\n} ][0]",
+        ] {
+            for declaration in [
+                "static X", "const X", "pub(in crate::owner) const X",
+                "pub\nconst X", "pub /* comment */ (crate) const X",
+                "pub // visibility\n(in crate::owner) static X",
+            ] {
+                let raw = format!("#[cfg(test)]\n{declaration}: usize = {initializer};\nfn real() {{ x.unwrap(); }}\n");
+                let projected = production_half(&raw);
+                assert!(!projected.contains("EXTRA_LIMIT"), "{projected}");
+                assert_eq!(projected.lines().last(), Some("fn real() { x.unwrap(); }"));
+                assert_eq!(projected.lines().count(), raw.lines().count(), "line positions");
+            }
+        }
+        // Const functions still end with their body, even when a comment has punctuation.
+        let konst_fn = "#[cfg(test)]\nconst fn helper() -> usize { 1 } // ;\nfn real() { x.unwrap(); }\n";
+        assert_eq!(production_half(konst_fn), "\n\nfn real() { x.unwrap(); }");
+        // Regression for proposed revision 4: nested comment delimiters are never code.
+        let nested = "#[cfg(test)]\nfn helper() { /* outer /* inner */ ( [ { ;\n tail ) ] } */ }\nfn production() { x.unwrap(); }\n";
+        assert_eq!(production_half(nested), "\n\n\nfn production() { x.unwrap(); }");
+        let open_delimiter = "#[cfg(test)]\nfn helper() { /* outer /* inner */ ( */ }\nfn production() { x.unwrap(); }\n";
+        assert_eq!(production_half(open_delimiter), "\n\nfn production() { x.unwrap(); }");
+
+        // Regression for proposed revision 2: comments are whitespace between keywords.
+        for trivia in ["/* explanation */", "// explanation\n", "/* outer /* nested */ tail */"] {
+            let raw = format!("#[cfg(test)]\nconst {trivia} fn helper() -> usize {{ 1 }}\nfn production() {{ x.unwrap(); }}\n");
+            let projected = production_half(&raw);
+            assert_eq!(projected.lines().last(), Some("fn production() { x.unwrap(); }"));
+            assert!(!projected.contains("helper"));
+            assert_eq!(projected.lines().count(), raw.lines().count());
+        }
+
+
+
     }
 
     /// What this catches: the production/test split silently swallowing the whole
--- a/core/source-hygiene/src/derived_bounds.rs
+++ b/core/source-hygiene/src/derived_bounds.rs
@@ -111,14 +111,6 @@
     "u8", "u16", "u32", "usize", "u64", "i32", "i64", "f32", "f64",
 ];
 
-/// Const declaration prefixes, longest first so `pub const` is not read as `const`.
-const CONST_PREFIXES: &[&str] = &[
-    "pub(crate) const ",
-    "pub(super) const ",
-    "pub const ",
-    "const ",
-];
-
 pub struct DerivedBounds;
 
 impl DerivedBounds {
@@ -188,9 +180,16 @@
     /// `(name, type, value)` if this line declares a numeric constant.
     fn const_declaration<'a>(code: &'a str) -> Option<(&'a str, &'a str, &'a str)> {
         let trimmed = code.trim_start();
-        let rest = CONST_PREFIXES
-            .iter()
-            .find_map(|p| trimmed.strip_prefix(*p))?;
+        // Visibility does not change whether a declaration is a numeric constant.
+        // Restricted visibility includes pub(in crate::owner), not only crate/super.
+        let declaration = if let Some(restricted) = trimmed.strip_prefix("pub(") {
+            restricted.split_once(')')?.1.trim_start()
+        } else if let Some(public) = trimmed.strip_prefix("pub ") {
+            public.trim_start()
+        } else {
+            trimmed
+        };
+        let rest = declaration.strip_prefix("const ")?;
         let (name, tail) = rest.split_once(':')?;
         let (ty, value) = tail.split_once('=')?;
         let ty = ty.trim();
@@ -410,6 +409,11 @@
         assert_eq!(DerivedBounds.check(&mk("let c = A_SECONDS * B_TOKENS_PER_S;")).len(), 1);
         // A live-path bound with a bare literal and nothing said about it.
         assert_eq!(DerivedBounds.check(&mk("const FILL_CAP_TOKENS: usize = 15_000;")).len(), 1);
+        // Regression for #5227: restricting visibility must not hide the same bound.
+        for visibility in ["pub", "pub(crate)", "pub(super)", "pub(self)", "pub(in crate::owner)"] {
+            let raw = format!("{visibility} const FILL_CAP_TOKENS: usize = 15_000;");
+            assert_eq!(DerivedBounds.check(&mk(&raw)).len(), 1, "{visibility}");
+        }
         // The same, derived from a measurement or another named bound: fine.
         assert!(DerivedBounds
             .check(&mk("const FILL_CAP_TOKENS: usize = BOOTSTRAP_WORKING_SET as usize;"))

[joelteply]

Codex review: SOURCE PASS at exact head 6ac1a84. My previous scanner blockers are resolved.

The integrated lib.rs and derived_bounds.rs are byte-for-byte identical to bcbab21 plus independently reviewed revision5.patch (SHA256 ce579e35aff9b5ebd98db15e644ddbed2be96682cf7ee5c35bea5bebcfcc1159). This resolves the earlier patch-hash discrepancy by checking resulting source. I re-read the delta: same-line cfg items, comment punctuation, const/static initializer continuations, restricted visibility and nested-comment cases are covered without swallowing following production. No baseline changes were introduced by this final correction.

Verified all eight checks green on this head. Independently read source-hygiene run39528575399: 42 tests passed, including gated-item regressions. Core tests and Windows compilation/custody/lifecycle also pass. No local compilation or deployment performed. The per-line layer rule remains a textual-reference ratchet, not proof of unchanged architectural coupling under arbitrary formatting; prior limitation still applies.

Review clears #5227 at this head. #5228 remains a separate review; this does not approve its entire sweep or claim live performance/learning results.