@@ -11,11 +11,11 @@ merging MCP frontend code or pushing worker branches.
 
 | Workstream | Worker result | Implementation evidence | Evidence gap |
 | --- | --- | --- | --- |
-| YAML removal guards | blocked | 523d398d; Windows-gated reparse-point and access-denied tests; 64 YAML tests passed | Native Windows execution; completion sidecar was initially read-only |
-| Version-cohort handoff | blocked | 01af5cb2; distinct cache-root handoff and Windows separator-form tests | Runtime assertions could not create secure temp roots via cbm_mkdtemp |
-| Complexity determinism | partial | 43d3a210; production build and changed objects compiled | Focused pipeline suite was interrupted while generated grammar objects stalled |
-| Razor / .cshtml | blocked | 5b1bc085; .cshtml language mapping, route extraction, and three regressions; 562 language/extraction tests passed | Completion sidecar was not finalized; native Windows is not required for this feature |
-| Embedded Svelte/HTML/Astro | partial | f8971e7a; implementation and focused tests committed; whitespace check passed | Test runner link failed on missing SQLite symbols, so extraction suites did not execute |
+| YAML removal guards | complete on Linux | 523d398d; Windows-gated reparse-point and access-denied tests; focused suite passed | Native Windows execution remains deferred |
+| Version-cohort handoff | complete on Linux | 01af5cb2; distinct cache-root handoff and Windows separator-form tests; focused suite passed | Native Windows execution remains deferred |
+| Complexity determinism | complete | 43d3a210; canonical tie-breaker and fixture corpus; pipeline suite passed | None |
+| Razor / .cshtml | complete | 5b1bc085; .cshtml language mapping, route extraction, and three regressions; focused suites passed | None |
+| Embedded Svelte/HTML/Astro | complete on Linux | f8971e7a; corrected test-runner linkage and focused extraction/structural/label suites passed | Native Windows execution is not required for this feature |
 
 The separate complexity-r2 run is not a sixth task. It only rechecked the
 complexity fixture and was blocked while writing its completion sidecar; its
@@ -167,13 +167,15 @@ qualification is required for Windows-specific claims. Commit the accepted
 integration as a separate release-tooling change; do not push until the full
 gate and release review are green.
 
-## Explicit deferrals
+## Remaining qualification deferrals
 
 - 92725a5e remains excluded: it is a Windows MCP stdio-server watchdog, not a
   CLI process behavior.
 - c1b9c451 remains excluded as a direct port; its MCP session adapter is
   obsolete. Any 9846c3f1 separator-equivalence behavior requires a separate
   neutral daemon implementation and test.
-- 24f54c0e is provisionally implemented in f8971e7a, but acceptance is blocked
-  on complete focused-suite linkage and review of the intentional graph/label
-  behavior changes. Revert or defer it if those gates cannot be met.
+- Native Windows execution of the YAML and cohort cases remains outstanding;
+  Linux cannot substitute for that evidence.
+- 24f54c0e is accepted on Linux in f8971e7a after the focused runner linked and
+  passed; its intentional graph/label behavior changes are covered by the
+  focused suites.
@@ -154,6 +154,41 @@ Benchmarking is only one part of the Windows RC gate. For the same exact executa
 8. generate `qualification-summary.md` and `qualification-manifest.json` against the exact artifact hashes;
 9. attach evidence to the draft release and use the existing promotion workflow.
 
+## Follow-up qualification batch
+
+The CP90 Windows follow-ups can be exercised in one native-Windows run. Build
+the source test runner once, then run both C follow-up suites, the existing
+native product guards, and the benchmark corpus without rebuilding between
+steps. Run this from a clean checkout when source-level test evidence is
+required; the RC orchestrator above remains the authority for immutable
+release-artifact evidence.
+
+```powershell
+$ErrorActionPreference = 'Stop'
+$make = (Get-Command make).Source
+& $make '-j' '-f' 'Makefile.cbm' 'build/c/test-runner' 'SANITIZE=' `
+  'TMP=' + $env:TEMP 'TEMP=' + $env:TEMP 'TMPDIR=' + $env:TEMP
+if ($LASTEXITCODE) { throw "test-runner build failed ($LASTEXITCODE)" }
+
+& 'build/c/test-runner' 'config_yaml_edit' 'version_cohort'
+if ($LASTEXITCODE) { throw "CP90 C follow-up tests failed ($LASTEXITCODE)" }
+
+& '.\scripts\test-windows.ps1' -GuardsOnly -Binary `
+  'build\c\codebase-memory-cli.exe'
+if ($LASTEXITCODE) { throw "native Windows guards failed ($LASTEXITCODE)" }
+
+& '.\scripts\qualification\run-windows-benchmark-corpus.ps1' `
+  -CandidateBinary 'build\c\codebase-memory-cli.exe' `
+  -ResultsRoot 'C:\cbm-benchmark\results\cp90-followup'
+if ($LASTEXITCODE) { throw "benchmark corpus failed ($LASTEXITCODE)" }
+```
+
+The YAML reparse-point/access-denied and cohort separator cases are the
+Windows-specific CP90 evidence. Record the complete console output and the
+timestamped benchmark result directory. A source-built executable is suitable
+for follow-up qualification only; it must not replace the exact published RC
+bytes used by the release qualification sequence.
+
 ## Manual fallback
 
 To benchmark one repository without the orchestrator:
 
@@ -7902,6 +7902,73 @@ void cbm_extract_definitions_without_module(CBMExtractCtx *ctx) {
     extract_variables(ctx, ctx->root, spec);
 }
 
+/* Razor's @page directive is outside the recovered C# AST. */
+static bool cbm_path_is_razor(const char *rel_path) {
+    if (!rel_path) {
+        return false;
+    }
+    static const char *const suffixes[] = {".razor", ".cshtml"};
+    size_t len = strlen(rel_path);
+    for (size_t i = 0; i < sizeof(suffixes) / sizeof(suffixes[0]); i++) {
+        size_t slen = strlen(suffixes[i]);
+        if (len > slen && strcmp(rel_path + len - slen, suffixes[i]) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static const char *razor_page_route_on_line(CBMArena *a, const char *line,
+                                             const char *line_end) {
+    static const char directive[] = "@page";
+    const size_t dlen = sizeof(directive) - 1U;
+    const char *p = line;
+    while (p < line_end && (*p == ' ' || *p == '\t')) {
+        p++;
+    }
+    if (p == line_end || (size_t)(line_end - p) <= dlen ||
+        strncmp(p, directive, dlen) != 0) {
+        return NULL;
+    }
+    p += dlen;
+    if (p == line_end || (*p != ' ' && *p != '\t')) {
+        return NULL;
+    }
+    while (p < line_end && (*p == ' ' || *p == '\t')) {
+        p++;
+    }
+    if (p == line_end || *p != '"') {
+        return NULL;
+    }
+    const char *route = ++p;
+    while (p < line_end && *p != '"') {
+        p++;
+    }
+    if (p == line_end || p == route || *route != '/') {
+        return NULL;
+    }
+    return cbm_arena_strndup(a, route, (size_t)(p - route));
+}
+
+static const char *cbm_razor_page_route(CBMArena *a, const char *source, int source_len) {
+    if (!source || source_len <= 0) {
+        return NULL;
+    }
+    const char *end = source + source_len;
+    for (const char *line = source; line < end;) {
+        const char *nl = memchr(line, '\n', (size_t)(end - line));
+        const char *route = razor_page_route_on_line(a, line, nl ? nl : end);
+        if (route) {
+            return route;
+        }
+        if (!nl) {
+            break;
+        }
+        line = nl + 1;
+    }
+    return NULL;
+}
+
 void cbm_extract_definitions(CBMExtractCtx *ctx) {
     const CBMLangSpec *spec = cbm_lang_spec(ctx->language);
     if (!spec) {
@@ -7923,6 +7990,13 @@ void cbm_extract_definitions(CBMExtractCtx *ctx) {
     mod.is_test = ctx->result->is_test_file;
     // #519: index what a config file declares itself to be, not only its path.
     mod.docstring = extract_config_module_description(ctx);
+    if (ctx->language == CBM_LANG_CSHARP && cbm_path_is_razor(ctx->rel_path)) {
+        const char *route = cbm_razor_page_route(a, ctx->source, ctx->source_len);
+        if (route) {
+            mod.route_path = route;
+            mod.route_method = "GET";
+        }
+    }
     cbm_defs_push(&ctx->result->defs, a, mod);
 
     cbm_extract_definitions_without_module(ctx);
 
@@ -1383,7 +1383,7 @@ static void parse_spec_imports(CBMExtractCtx *ctx) {
     ts_tree_cursor_delete(&cursor);
 }
 
-// --- Embedded-language imports ---
+// --- Embedded-language structure and imports ---
 // Generic walker for host grammars (Svelte, Vue, HTML, Astro, ...) whose AST
 // keeps embedded sub-language source as raw_text (or similar) without parsing
 // it.  The host's CBMLangSpec.embedded_imports declares which content nodes
@@ -1462,62 +1462,74 @@ static bool ascii_trimmed_equals(const char *value, const char *expected) {
  * its inline programs to the language forms whose parsers we can select
  * exactly. A src attribute always denotes an external program and therefore
  * suppresses any inline extraction, even for malformed mixed markup. */
-static bool vue_embedded_language(CBMExtractCtx *ctx, TSNode script, CBMLanguage *language) {
-    enum { VUE_ATTR_STACK_CAP = 128 };
-    TSNode stack[VUE_ATTR_STACK_CAP];
+static const char *script_attribute_value(CBMExtractCtx *ctx, TSNode attribute) {
+    TSNode value_node = attribute;
+    if (!find_first_descendant_of(attribute, "attribute_value", &value_node)) {
+        return "";
+    }
+    return cbm_node_text(ctx->arena, value_node, ctx->source);
+}
+
+static bool apply_script_attribute(CBMExtractCtx *ctx, TSNode attribute, CBMLanguage *language) {
+    if (ts_node_named_child_count(attribute) == 0) {
+        return false;
+    }
+    const char *name = cbm_node_text(ctx->arena, ts_node_named_child(attribute, 0), ctx->source);
+    if (ascii_trimmed_equals(name, "src")) {
+        return false;
+    }
+    if (ascii_trimmed_equals(name, "lang")) {
+        const char *value = script_attribute_value(ctx, attribute);
+        if (ascii_trimmed_equals(value, "js") || ascii_trimmed_equals(value, "javascript")) {
+            *language = CBM_LANG_JAVASCRIPT;
+            return true;
+        }
+        if (ascii_trimmed_equals(value, "ts") || ascii_trimmed_equals(value, "typescript")) {
+            *language = CBM_LANG_TYPESCRIPT;
+            return true;
+        }
+        return false;
+    }
+    if (ascii_trimmed_equals(name, "type")) {
+        const char *value = script_attribute_value(ctx, attribute);
+        return ascii_trimmed_equals(value, "") || ascii_trimmed_equals(value, "module") ||
+               ascii_trimmed_equals(value, "text/javascript") ||
+               ascii_trimmed_equals(value, "application/javascript");
+    }
+    return true;
+}
+
+static bool script_embedded_language(CBMExtractCtx *ctx, TSNode script, CBMLanguage *language) {
+    enum { SCRIPT_ATTR_STACK_CAP = 128 };
+    TSNode stack[SCRIPT_ATTR_STACK_CAP];
     int top = 0;
-    bool has_lang = false;
-    bool lang_supported = true;
-    CBMLanguage selected = CBM_LANG_JAVASCRIPT;
     stack[top++] = script;
     while (top > 0) {
         TSNode node = stack[--top];
         if (strcmp(ts_node_type(node), "attribute") == 0) {
-            uint32_t named_count = ts_node_named_child_count(node);
-            if (named_count == 0) {
-                return false;
-            }
-            TSNode name_node = ts_node_named_child(node, 0);
-            char *name = cbm_node_text(ctx->arena, name_node, ctx->source);
-            if (ascii_trimmed_equals(name, "src")) {
+            if (!apply_script_attribute(ctx, node, language)) {
                 return false;
             }
-            if (ascii_trimmed_equals(name, "lang")) {
-                TSNode value_node = node;
-                if (!find_first_descendant_of(node, "attribute_value", &value_node)) {
-                    return false;
-                }
-                char *value = cbm_node_text(ctx->arena, value_node, ctx->source);
-                has_lang = true;
-                if (ascii_trimmed_equals(value, "js") ||
-                    ascii_trimmed_equals(value, "javascript")) {
-                    selected = CBM_LANG_JAVASCRIPT;
-                } else if (ascii_trimmed_equals(value, "ts") ||
-                           ascii_trimmed_equals(value, "typescript")) {
-                    selected = CBM_LANG_TYPESCRIPT;
-                } else {
-                    lang_supported = false;
-                }
-            }
             continue;
         }
         uint32_t count = ts_node_named_child_count(node);
-        if ((int)count > VUE_ATTR_STACK_CAP - top) {
+        if ((int)count > SCRIPT_ATTR_STACK_CAP - top) {
             return false;
         }
         for (int i = (int)count - 1; i >= 0; i--) {
             stack[top++] = ts_node_named_child(node, (uint32_t)i);
         }
     }
-    if (has_lang && !lang_supported) {
-        return false;
-    }
-    *language = selected;
     return true;
 }
 
+static bool markup_script_host(CBMLanguage language) {
+    return language == CBM_LANG_VUE || language == CBM_LANG_SVELTE || language == CBM_LANG_HTML ||
+           language == CBM_LANG_ASTRO;
+}
+
 static void parse_one_embedded_block(CBMExtractCtx *ctx, const CBMEmbeddedBlock *block,
-                                     CBMLanguage embedded_language, bool extract_structure) {
+                                     CBMLanguage embedded_language) {
     const TSLanguage *language = cbm_ts_language(embedded_language);
     if (!language || ctx->source_len < 0) {
         return;
@@ -1564,13 +1576,9 @@ static void parse_one_embedded_block(CBMExtractCtx *ctx, const CBMEmbeddedBlock
         .macro_table = ctx->macro_table,
         .return_type_table = ctx->return_type_table,
     };
-    if (extract_structure) {
-        cbm_extract_definitions_without_module(&sub_ctx);
-    }
+    cbm_extract_definitions_without_module(&sub_ctx);
     walk_es_imports(&sub_ctx, sub_ctx.root);
-    if (extract_structure) {
-        cbm_extract_unified(&sub_ctx);
-    }
+    cbm_extract_unified(&sub_ctx);
 
     ts_tree_delete(tree);
     ts_parser_delete(parser);
@@ -1591,19 +1599,17 @@ static void parse_embedded_imports(CBMExtractCtx *ctx) {
             /* Structure (defs + calls), not just imports, for hosts whose
              * embedded language carries real code. Vue since #1852; CFML's
              * <cfscript> since the #1412 distillation. */
-            bool extract_structure =
-                ctx->language == CBM_LANG_VUE || ctx->language == CBM_LANG_CFML;
             /* The attribute resolver is Vue's: it inspects <script lang=/src=>
              * and OVERRIDES the spec's embedded language (JS default, TS on
              * lang="ts", bail on src=). CFML's cf_script_tag carries no such
              * attributes and its embedded language is fixed by the spec row
              * (CFSCRIPT) — running the resolver would silently rewrite it to
              * JavaScript. Resolve only for Vue. */
-            if (ctx->language == CBM_LANG_VUE &&
-                !vue_embedded_language(ctx, hits[i].script, &embedded_language)) {
+            if (markup_script_host(ctx->language) &&
+                !script_embedded_language(ctx, hits[i].script, &embedded_language)) {
                 continue;
             }
-            parse_one_embedded_block(ctx, &hits[i], embedded_language, extract_structure);
+            parse_one_embedded_block(ctx, &hits[i], embedded_language);
         }
     }
 }
 
@@ -917,8 +917,8 @@ static const CBMEmbeddedLangSpec astro_embedded_imports[] = {
     /* Astro component scripts live in the `---` frontmatter fence, which the
      * grammar keeps as an unparsed frontmatter_js_block. Re-parse that slice
      * with the JS grammar so `import X from './X.astro'` becomes a real edge. */
-    {"frontmatter", "frontmatter_js_block", CBM_LANG_JAVASCRIPT},
-    {"script_element", "raw_text", CBM_LANG_JAVASCRIPT},
+    {"frontmatter", "frontmatter_js_block", CBM_LANG_TYPESCRIPT},
+    {"script_element", "raw_text", CBM_LANG_TYPESCRIPT},
     {NULL, NULL, 0},
 };
 
 
@@ -50,6 +50,10 @@ static const ext_entry_t EXT_TABLE[] = {
 
     /* C# */
     {".cs", CBM_LANG_CSHARP},
+    /* Razor components and Pages use the C# grammar for their code blocks;
+     * surrounding markup is best-effort and may be reported as partial. */
+    {".razor", CBM_LANG_CSHARP},
+    {".cshtml", CBM_LANG_CSHARP},
 
     /* Clojure */
     {".clj", CBM_LANG_CLOJURE},
 
@@ -113,6 +113,10 @@ static const char *str_or_empty(const char *s) {
     return s ? s : "";
 }
 
+static int cmp_int(int a, int b) {
+    return a < b ? TLD_CMP_LESS : a > b ? TLD_CMP_GREATER : 0;
+}
+
 static int cmp_node_canonical(const cbm_gbuf_node_t *a, const cbm_gbuf_node_t *b) {
     int r = strcmp(str_or_empty(a ? a->qualified_name : NULL),
                    str_or_empty(b ? b->qualified_name : NULL));
@@ -123,12 +127,19 @@ static int cmp_node_canonical(const cbm_gbuf_node_t *a, const cbm_gbuf_node_t *b
     if (r != 0) {
         return r;
     }
-    int la = a ? a->start_line : 0;
-    int lb = b ? b->start_line : 0;
-    if (la != lb) {
-        return la < lb ? TLD_CMP_LESS : TLD_CMP_GREATER;
+    r = cmp_int(a ? a->start_line : 0, b ? b->start_line : 0);
+    if (r != 0) {
+        return r;
+    }
+    r = cmp_int(a ? a->end_line : 0, b ? b->end_line : 0);
+    if (r != 0) {
+        return r;
+    }
+    r = strcmp(str_or_empty(a ? a->name : NULL), str_or_empty(b ? b->name : NULL));
+    if (r != 0) {
+        return r;
     }
-    return 0;
+    return strcmp(str_or_empty(a ? a->label : NULL), str_or_empty(b ? b->label : NULL));
 }
 
 static int cmp_seed_canonical(const void *pa, const void *pb) {
 
@@ -480,10 +480,12 @@ static int ensure_one_decorator_route(cbm_gbuf_t *gb, const cbm_gbuf_node_t *fun
 
 /* Phase 2a: Ensure all functions with route_path properties have Route+HANDLES edges. */
 static void ensure_decorator_routes(cbm_gbuf_t *gb) {
-    const char *labels[] = {"Function", "Method"};
+    /* Razor components/pages carry their route on the implicit Module. */
+    const char *labels[] = {"Function", "Method", "Module"};
+    const int label_count = (int)(sizeof(labels) / sizeof(labels[0]));
     int created = 0;
 
-    for (int li = 0; li < RN_STRIP_PASSES; li++) {
+    for (int li = 0; li < label_count; li++) {
         const cbm_gbuf_node_t **nodes = NULL;
         int count = 0;
         if (cbm_gbuf_find_by_label(gb, labels[li], &nodes, &count) != 0) {