P1-P7 阶段总览

归档说明：这是收口前的详细快照，保留逐轮展开的长文结构。其中部分样例数量表述已被当前文档修正；当前事实面以 /roadmap/phase-progress 与 /roadmap/current-supported-surface 为准。

最后同步时间：2026-04-03

这份文档不是路线图，而是对当前已经完成与正在推进的 P1-P7 开发工作的阶段性归档。目标是回答三个问题：

每个阶段原本要解决什么问题
现在到底已经做到了什么
还有哪些边界是刻意保留、暂时没有继续往下做

如果需要看更细的设计拆解，请继续阅读：

开发计划
编译器流水线
工具链设计
/plans 下的合并设计稿与归档切片稿

总体结论

当前仓库已经不再是“只有语言设计文档”的预研空壳，而是形成了六层真实地基：

P1 建立了可解析、可格式化、可回归测试的前端最小闭环
P2 建立了 HIR、名称解析、first-pass typing、统一诊断和最小 LSP/查询闭环
P3 建立了结构化 MIR、ownership facts、cleanup-aware 分析和 closure escape groundwork
P4 建立了 LLVM 文本后端、ql build、对象文件/可执行文件/静态库产物路径，以及第一版 codegen golden harness
P5 建立了最小 C ABI 互操作闭环，包括导出、导入、头文件生成、静态库/动态库集成和 sidecar header
P6 建立了 same-file editor semantics 强化层，把 query / rename / completion / semantic tokens / LSP bridge 做到更稳定的一致性

这几期的核心价值不是“功能很多”，而是已经把前端、语义、中端、后端、FFI、CLI、LSP、测试、文档这几个大边界稳定下来。后续继续开发时，重点应该是沿着这些边界扩展，而不是回头推翻它们。

P1: 前端最小闭环

阶段目标

P1 的任务是把 Qlang 从纯设计稿推进到“能读、能写、能稳定回归”的前端工程基线。重点不是语义正确性，而是：

Rust workspace 和 crate 拆分
lexer / parser / AST
ql check 与 qfmt
可维护的 parser 测试与 formatter 稳定性测试

切片进度

P1.1 Workspace 与基础前端骨架

已完成：

建立 Rust workspace
新增 ql-span、ql-ast、ql-lexer、ql-parser、ql-fmt、ql-cli
建立 ql check / ql fmt 的最小 CLI 入口

这一刀解决的是“项目能不能开始长期演进”的问题，而不是语法覆盖率问题。

P1.2 基础声明、类型与表达式

已完成：

package / use
const / static / type / opaque type
fn / trait / impl / extend / extern
struct / data struct / enum
generics、where、泛型类型应用、callable type、tuple return
闭包、结构体字面量、基础运算表达式
unsafe fn 和 unsafe { ... }

这一步把语言草案里的核心声明面做成了可解析的真实前端。

P1.3 控制流、模式匹配与 formatter 稳定化

已完成：

if / match expression
while / loop / for / for await
richer pattern：路径模式、tuple-struct 模式、struct 模式、字面量模式
parser fixture 覆盖控制流和声明切片
formatter 对当前语法面的稳定 round-trip

这一刀的重点是防止 parser 变成“一堆 declaration rule 的堆叠”，让控制流和模式系统尽早进入回归面。

P1.4 顶层声明补全与错误恢复增强

已完成：

parser 从单文件拆成 item / expr / pattern / stmt
统一函数签名模型，覆盖 free function、trait method、extern function
修复控制流头部与 struct literal 歧义
加固错误恢复与 fixture 回归

这一步的价值是把前端从“能跑”提升到“后面还能继续维护”。

P1.5 为 HIR lowering 预留前端边界

已完成：

AST 节点级 span
精确 identifier / receiver span
单元素 tuple type / expr 稳定 round-trip
*const 指针类型、转义标识符、下划线前缀绑定、pub extern block round-trip
ql check 根目录扫描过滤 fixture、工具输出目录和用户 scratch 目录

这一步本质上是在为 P2 的 HIR / diagnostics / query 做准备，避免后面被迫大改 AST。

已交付能力

ql check 能稳定解析和报告 span 级语法错误
ql fmt 能对当前前端语法集工作
parser / formatter regression 基础已经建立

关键 crate

crates/ql-span
crates/ql-ast
crates/ql-lexer
crates/ql-parser
crates/ql-fmt
crates/ql-cli

当前边界

P1 已完成。当前不再把“补更多 parser 规则”视为主线目标，后续前端变化应服务于 HIR、typeck、MIR 和后端需求。

P2: 语义分析与类型检查地基

阶段目标

P2 的目标不是一步做完整类型系统，而是建立统一语义边界，让 CLI、LSP 和后续中端都能共享同一份真相源：

HIR
名称解析
first-pass typing
统一 diagnostics
最小 position-based semantic query
最小 LSP

切片进度

P2.1 HIR 与统一诊断边界

已完成：

新增 ql-diagnostics
新增 ql-analysis
新增 ql-hir
ql check 切到 parser -> HIR lowering -> resolve -> semantic/type diagnostics 的统一流水线
HIR arenas、稳定 ID、local binding lowering

这一刀把“前端产物”从 AST 推进到真正能被语义阶段消费的 HIR。

P2.2 名称解析与作用域图

已完成：

新增 ql-resolve
lexical scope graph 覆盖 module / callable / block / closure / match arm / for-loop
best-effort resolution 覆盖 local、param、receiver self、generic、import alias、builtin type、struct literal root、pattern path root
记录 item scope / function scope，给 query / LSP 提供稳定锚点

当前策略是故意保守：先解析可靠根绑定，再逐步把 struct field / unique method / enum variant token 纳入 query；但仍不冒进宣称 full module-path 语义已经成立。

P2.3 First-pass typing

已完成：

return-value type mismatch
if / while / match guard 的 Bool 条件检查
callable arity / argument typing
top-level const / static value typing 传播
tuple-based multi-return destructuring
expected callable type 下的 direct closure checking
struct literal field / missing-field / type checking
source-level fixed array type expr [T; N]
homogeneous array literal inference 与 expected fixed-array context 下的 array item type checking
保守 tuple / array indexing：array element projection、支持 lexer-style integer literal 的 constant tuple indexing、array index type checking、tuple out-of-bounds diagnostics
same-file local import alias value/callable typing（function / const / static）
comparison operand compatible-numeric checking
bare mutable binding assignment diagnostics（var local / var self）
const / static / function / import assignment-target diagnostics
explicit unsupported member / index assignment-target diagnostics
ambiguous method member diagnostics
invalid projection receiver diagnostics
invalid struct-literal root diagnostics
invalid pattern-root shape diagnostics
invalid path-pattern root diagnostics
same-file const bare path-pattern literal folding + unsupported static/non-scalar path-pattern diagnostics
positional-after-named diagnostics
equality operand compatibility
struct member existence checking
pattern root / literal compatibility
calling non-callable values

这一步已经足够支撑“中小样例的可信类型诊断”，但还不是完整类型系统。

当前仍刻意保留的边界：

assignment target 现在仍然只在 bare binding 级别开放真实写入语义；但 const / static / function / import binding 已有显式不可赋值诊断，member/index place assignment 也已改成显式 unsupported 诊断，避免静默漏诊
ambiguous method 现在已经会给出显式 type diagnostics，但 same-file query / completion / rename 仍然只接受唯一 candidate，不会伪造 ambiguous member truth surface
invalid projection receiver diagnostics 现在也只覆盖已知必错的类型；generic、unresolved 与 deeper import-module case 仍刻意保守
invalid deeper path-like call 现在也有显式回归覆盖：当 receiver 已知必错时，不会继续偷用 root function/import signature，因此 ping.scope(true) 这类 case 不会再额外冒出伪造的 call-argument mismatch
invalid struct-literal root diagnostics 现在也覆盖 builtin / generic root、root 已解析成功且明确不支持 struct-style 字段构造的 case，以及 same-file 已解析二段 enum variant path 上的 unknown variant；deeper module-path 仍刻意保守
unsupported 或仍 deferred 的 struct literal root 现在也会回退成 unknown，避免再泄漏伪造的具体 item type 并触发误导性的后续 return/assignment mismatch
deferred multi-segment type path 现在也会保持 source-backed Named 形态，不再把 same-file local item / import alias 过早 canonicalize 成具体 item type
deferred multi-segment impl / extend target 现在也有显式回归覆盖：它们不会再被错误投影到 concrete local receiver surface 上，因此 Counter.Scope.Config 这类 deferred path 的方法不会伪装成 same-file Counter 的成员
invalid pattern-root shape diagnostics 现在也只覆盖 pattern root 已解析成功且明确不支持当前 struct/tuple 构造形状的 case，以及 same-file 已解析二段 enum variant path 上的 unknown variant；path pattern shape 与 deeper module-path 仍刻意保守
invalid path-pattern root diagnostics 现在也只覆盖 path root 已解析成功且明确不支持 bare path 形状的 case；unit variant 仍允许，同文件已解析二段 enum variant path 的 unknown variant 现在也会显式报错
same-file bare const path pattern 现在也已接入 Bool / Int literal folding，但仍只覆盖 same-file root 与 same-file local import alias；static、非标量 const path，以及 cross-file / deeper module-path constant pattern 语义仍刻意保守

P2.4 Duplicate / semantic diagnostics 硬化

已完成：

duplicate top-level definition
duplicate generic parameter
duplicate function parameter
duplicate enum variant
duplicate method in trait / impl / extend
duplicate pattern binding
duplicate struct / struct-pattern / struct-literal field
duplicate named call argument
positional-after-named
invalid self outside method receiver scope

同时，identifier / receiver span 已经从 AST 打通到 diagnostics，避免误锚到整个函数或整个语句。

P2.5 Position-based query 与最小 LSP

已完成：

ql-analysis 暴露 symbol_at / hover_at / definition_at
ql-analysis 暴露 references_at，通过稳定 symbol identity 聚合同文件 occurrence
ql-analysis 暴露 prepare_rename_at / rename_at，基于同一份 QueryIndex 产出同文件 rename edits
ql-analysis 暴露 completions_at，基于 resolver lexical scope 与同一份 symbol identity 产出同文件 completion 候选
ql-analysis 暴露 semantic_tokens()，基于同一份 QueryIndex occurrence 产出 source-backed semantic token occurrence
查询覆盖 item / local / param / generic / receiver self / enum variant token / struct field member / explicit struct field label / unique method member / named type root / pattern path root / struct literal root
import alias 现在是 source-backed symbol：支持 hover / definition / 同文件 references / 同文件 rename / semantic tokens；builtin type 则继续作为非 source-backed stable symbol 参与 hover / references / semantic tokens，但不提供 definition / rename
ql-typeck 现在还会把同文件单段 local import alias 规范化回本地 item，用于 struct literal 字段检查、struct / enum pattern root 检查，以及同文件 function / const / static item alias 的 value typing / callable signature
ql-typeck 现在还会把 enum struct-variant literal 的字段检查接到同一条路径上，same-file local import alias -> local enum item 也会复用这条 canonicalization；这仍是 typing 能力，不代表 query surface 已经支持 variant field symbols
ql-typeck 现在还会对 struct pattern 的未知字段报错，这条校验同样会复用同文件 local import alias -> local item 的 canonicalization
method declaration span 现在会精确保留到 HIR，同一 impl 里的多个方法会记录不同 function scope
named path segment span 现在也会精确保留，enum variant 的 pattern / constructor token 可以稳定参与 query 与 LSP
explicit struct literal / struct pattern 字段标签现在也会进入 field query surface，但 shorthand Point { x } token 仍刻意保守，继续落在 local/binding 语义；当从 source-backed field symbol 发起 rename，或从该 shorthand token 上发起 renameable binding symbol 的 rename 时，这些 shorthand site 都会被自动扩写成显式标签
这条 shorthand binding rename 回归现在还额外锁住了 const / static item，避免字段标签在 item-value shorthand 场景下被误改
function shorthand-binding rename parity 现在也有显式回归覆盖，锁住了 Ops { add_one } 这类 shorthand token 在 analysis / LSP 两层的 same-file prepare-rename / rename 一致性，保证 field label 保留且 rename 只落到 function declaration / use
type-namespace item same-file rename 现在也有显式回归覆盖，锁住了 type / opaque type / struct / enum / trait 在 analysis / LSP 两层的共享 item identity
type-namespace item same-file references / semantic tokens 现在也有显式回归覆盖，锁住了 type / opaque type / struct / enum / trait 的 query / highlighting 一致性
type-namespace item same-file hover / definition 现在也有显式回归覆盖，锁住了 type / opaque type / struct / enum / trait 的导航与悬浮一致性
type-namespace item aggregate parity 现在也有显式回归覆盖，锁住了 type / opaque type / struct / enum / trait 这组 same-file item surface 在 analysis / LSP 两层的聚合 hover / definition / references / semantic-token 一致性
global value item same-file query 现在也有显式回归覆盖，锁住了 const / static 在 analysis / LSP 两层的 hover / definition / references / semantic-token 一致性
extern callable same-file parity 现在也有显式回归覆盖，锁住了 extern block function declaration、顶层 extern "c" declaration，以及顶层 extern "c" function definition / call site 在 analysis / LSP 两层的 hover / definition / references / rename / semantic-token 一致性
extern callable value completion 现在也有显式回归覆盖，锁住了 extern block function declaration、顶层 extern "c" declaration，以及顶层 extern "c" function definition 在 analysis / LSP 两层的 FUNCTION completion item 映射、detail 与 text-edit 一致性
free function query parity 现在也有显式回归覆盖，锁住了 ordinary free function direct call site 在 analysis / LSP 两层的 hover / definition / references 一致性，而不是只靠 completion / rename 或聚合 root-binding 测试间接覆盖
free function semantic-token parity 现在也有显式回归覆盖，锁住了 ordinary free function declaration / direct call site 在 analysis / LSP 两层的 semantic-token 一致性，而不是只靠聚合 semantic-token 快照间接覆盖
callable surface aggregate parity 现在也有显式回归覆盖，锁住了 extern block callable、顶层 extern "c" 声明、顶层 extern "c" 定义与 ordinary free function 这组 same-file callable surface 在 analysis / LSP 两层的聚合 hover / definition / references / semantic-token 一致性
plain import alias same-file parity 现在也有显式回归覆盖，锁住了 import binding 在 analysis / LSP 两层的 hover / definition / references / semantic-token 一致性
plain import alias completion parity 现在也有显式回归覆盖，锁住了 import binding 在 analysis / LSP 两层的 type-context completion 与 MODULE completion item 映射
free function completion parity 现在也有显式回归覆盖，锁住了 lexical value completion 中的 free-function candidate 以及 LSP FUNCTION completion item 映射
plain import alias value completion parity 现在也有显式回归覆盖，锁住了 lexical value completion 中的 source-backed import candidate 以及 LSP MODULE completion item 映射
builtin / struct type completion parity 现在也有显式回归覆盖，锁住了 type-context completion 中的 builtin type / local struct candidate 以及 LSP CLASS / STRUCT completion item 映射
type alias completion parity 现在也有显式回归覆盖，锁住了 same-file type-context completion 中的 type alias candidate 以及 LSP CLASS completion item 映射
opaque type completion parity 现在也有显式回归覆盖，锁住了 same-file type-context completion 中的 opaque type candidate 以及带 opaque type ... detail 的 LSP CLASS completion item 映射
generic completion parity 现在也有显式回归覆盖，锁住了 same-file type-context completion 中的 generic candidate 以及 LSP TYPE_PARAMETER completion item 映射
enum completion parity 现在也有显式回归覆盖，锁住了 same-file type-context completion 中的 enum candidate 以及 LSP ENUM completion item 映射
trait completion parity 现在也有显式回归覆盖，锁住了 same-file type-context completion 中的 trait candidate 以及 LSP INTERFACE completion item 映射
field completion parity 现在也有显式回归覆盖，锁住了 stable receiver member completion 中的 field candidate 以及 LSP FIELD completion item 映射
unique method completion parity 现在也有显式回归覆盖，锁住了 stable receiver member completion 中的唯一 method candidate 以及 LSP FUNCTION completion item 映射
const / static completion parity 现在也有显式回归覆盖，锁住了 same-file lexical value completion 中的 const / static candidate 以及 LSP CONSTANT completion item 映射
local value completion parity 现在也有显式回归覆盖，锁住了 same-file lexical value completion 中的 local candidate 以及 LSP VARIABLE completion item 映射
parameter completion parity 现在也有显式回归覆盖，锁住了 same-file lexical value completion 中的 parameter candidate 以及 LSP VARIABLE completion item 映射
lexical value candidate-list parity 现在也有显式回归覆盖，锁住了 import / const / static / extern callable / free function / local / parameter 这些 same-file value candidate 的完整有序列表、detail 渲染与 replacement text-edit 投影
enum variant completion parity 现在也有显式回归覆盖，锁住了 parsed enum path completion 中的 variant candidate 以及 LSP ENUM_MEMBER completion item 映射
import alias variant completion parity 现在也有显式回归覆盖，锁住了 local import alias -> same-file enum item 这条 parsed variant-path completion 中的 variant candidate 以及 LSP ENUM_MEMBER completion item 映射
import alias struct-variant completion parity 现在也有显式回归覆盖，锁住了 local import alias -> same-file enum item 这条 struct-literal variant-path completion 中的 variant candidate 以及 LSP ENUM_MEMBER completion item 映射
remaining variant-path completion parity 现在也有显式回归覆盖，锁住了 direct struct-literal path 与 direct/local-import-alias pattern path 上既有的 variant candidate 以及 LSP ENUM_MEMBER completion item 映射
variant-path candidate-list parity 现在也有显式回归覆盖，锁住了 enum-root / struct-literal / pattern path 及其 same-file import-alias 镜像上下文的完整有序 variant candidate 列表、detail 渲染与 replacement text-edit 投影
deeper variant-like member chain 现在也有显式回归覆盖，锁住了只有 root enum item / same-file import alias 的第一段 variant tail 才能复用 variant truth；Command.Retry.more / Cmd.Retry.more 不会再伪造同文件 query identity 或 ENUM_MEMBER completion
deeper variant-like member chain 的关闭边界现在也被显式锁到 rename / semantic-token 两层，因此这类更深 member chain 既不能被错误 rename，也不会再被投影成 enum-member semantic token
deeper struct-literal / pattern variant-like path 现在也有显式回归覆盖，锁住了只有严格两段 Root.Variant path 才能复用 variant truth；Command.Scope.Config { ... } / Cmd.Scope.Retry(...) 不会再伪造同文件 query / rename / semantic-token identity 或 ENUM_MEMBER completion
deeper struct-like path 的 field truth 现在也有显式回归覆盖，锁住了只有严格 root struct path 才能复用 field truth；Point.Scope.Config { x: ... } / P.Scope.Config { x: ... } 不会再伪造同文件 field query / rename / semantic-token identity
deeper struct-like shorthand token 的 lexical fallback 现在也有显式回归覆盖，锁住了 Point.Scope.Config { x } / Point.Scope.Config { source } 这类 token 继续落在 local / binding / import surface；references 与 semantic tokens 也沿用这条 lexical truth，同文件 rename 会保持 raw binding edit，不会伪造 field-label expansion
completion filtering parity 现在也有显式回归覆盖，锁住了 lexical value visibility/shadowing 与 impl-preferred member filtering 这两条 already-supported same-file completion boundary 在 analysis / LSP 两层的一致性；其中 lexical value visibility 的聚合回归现在也已经显式覆盖 import / function / local 的 detail 与 text-edit 投影，而 impl-preferred member 聚合回归现在也已经显式覆盖 surviving candidate count 以及稳定 detail / text-edit 投影
completion candidate-list parity 现在也有显式回归覆盖，锁住了 type-context 与 stable-member completion 的完整候选列表、排序与命名空间边界在 analysis / LSP 两层的一致性；其中 type-context 总表现在已经显式覆盖 builtin / import / struct / type / opaque type / enum / trait / generic，而 stable-member 总表现在也已经显式覆盖 method / field 的 detail 与 text-edit 投影
shorthand query boundary parity 现在也有显式回归覆盖，锁住了 shorthand struct field token 继续落在 local/binding surface 而不是 field surface 的 same-file 查询边界在 analysis / LSP 两层的一致性
direct query parity 现在也有显式回归覆盖，锁住了 direct enum variant token 与 direct explicit struct field label 的 same-file definition / references 在 analysis / LSP 两层的一致性
direct semantic-token parity 现在也有显式回归覆盖，锁住了 direct enum variant token 与 direct explicit struct field label 的 same-file semantic-token/highlighting 在 analysis / LSP 两层的一致性
direct symbol surface aggregate parity 现在也有显式回归覆盖，锁住了 direct enum variant token 与 direct explicit struct field label 这组 same-file direct-symbol surface 在 analysis / LSP 两层的聚合 hover / definition / references / semantic-token 一致性
direct member query parity 现在也有显式回归覆盖，锁住了 direct field member 与唯一 method member 的 same-file hover / definition / references 在 analysis / LSP 两层的一致性
direct member semantic-token parity 现在也有显式回归覆盖，锁住了 direct field member 与唯一 method member 的 same-file semantic-token/highlighting 在 analysis / LSP 两层的一致性
direct member surface aggregate parity 现在也有显式回归覆盖，锁住了 direct field member 与唯一 method member 这组 same-file direct-member surface 在 analysis / LSP 两层的聚合 hover / definition / references / semantic-token 一致性
impl-preferred member query parity 现在也有显式回归覆盖，锁住了 direct member query 中 impl 优先于 extend 的 same-file hover / definition / references 在 analysis / LSP 两层的一致性
lexical semantic symbol same-file parity 现在也有显式回归覆盖，锁住了 generic / parameter / local / receiver self / builtin type 在 analysis / LSP 两层的 hover / definition / references / semantic-token 一致性；builtin type 仍无 definition / rename
lexical rename parity 现在也有显式回归覆盖，锁住了 generic / parameter / local 在 analysis / LSP 两层的 same-file rename 行为，并继续保持 receiver self / builtin type 的 rename surface 关闭
root value-item rename parity 现在也有显式回归覆盖，锁住了 function / const / static 在 analysis / LSP 两层的 same-file prepare-rename / rename 一致性，而不是只靠聚合 analysis 测试或 shorthand-binding 回归间接覆盖
同文件 local import alias -> local struct item 现在也会进入这条 field query / references / rename / semantic-token surface，显式字段标签和 field-driven shorthand rewrite 会继续映射回原 struct field symbol
same-file rename 当前只开放 function / const / static / struct / enum / variant / trait / type alias / import / field / method（仅唯一 candidate）/ local / parameter / generic；ambiguous method / receiver / builtin type / 从 shorthand field token 本身发起的 field-symbol rename 与 cross-file rename 仍然刻意不开放
same-file completion 当前会复用 ql-resolve 的 scope graph 和 ql-analysis 的 symbol data，已覆盖 lexical scope 的 value/type completion、稳定 receiver type 的 parsed member token completion、same-file parsed enum variant path completion，以及 local import alias -> local enum item 的 variant follow-through；同一条 follow-through 也已经进入 same-file query / rename / semantic token surface；completion 候选现在还会区分语义 label 与源码 insert text，因此 keyword-named escaped identifier 会继续生成合法编辑；ambiguous member completion、parse-error tolerant dot-trigger completion、import-graph/module-path deeper completion、foreign import alias variant semantics 与 cross-file/project-indexed completion 仍刻意不开放
same-file semantic tokens 当前会复用 ql-analysis 的 source-backed occurrence 与 SymbolKind，已覆盖统一 query surface 中的稳定语义 token；ambiguous / unresolved / parse-error token 与跨文件 semantic classification 仍刻意不开放
resolver 现在也补上了保守 unresolved diagnostics：bare value name、bare named type、single-segment pattern root 与 struct literal root 会报 unresolved，而 multi-segment module/import path 仍刻意不报
新增 ql-lsp
qlsp 支持 open/change/close、live diagnostics、hover、go to definition、same-file find references、same-file lexical-scope completion、same-file parsed member-token completion、same-file parsed enum variant-path completion、local import alias -> local enum item 的 variant-path query / completion / rename / semantic-token follow-through、local import alias -> local struct item 的 struct-field query / references / rename / semantic-token follow-through、same-file semantic tokens、same-file prepare rename / rename
qlsp 现在还支持 textDocument/semanticTokens/full，直接桥接 analysis semantic token occurrence
LSP bridge 完成 UTF-16 position、span/range、compiler diagnostic -> LSP diagnostic，以及 analysis completion / semantic tokens / rename -> LSP 响应的边界转换
diagnostics bridge parity 现在也有显式回归覆盖，锁住了 compiler Warning / Note 到 LSP severity 的映射、无 label diagnostics 回退到 0:0 range 且 related_information = None、无 primary label 时使用第一条 label span、仅 primary label 时 related_information = None，以及 secondary label 的 related-information 顺序与 message 回退（默认 related span）和 source = ql 协议行为
UTF-16 / CRLF position-range bridge parity 现在也有显式回归覆盖，锁住了 surrogate-pair 中间位置返回空、CRLF 行尾不接受越界 character、空尾行 Position 可回落到 EOF，以及跨 CRLF 多行 Span -> Range 投影与上层 hover / definition / references / completion / rename 在非法位置上的安全退空行为
semantic-token UTF-16 / CRLF parity 现在也有显式回归覆盖，锁住了 CRLF 文本中“同一行前缀含 emoji”场景的 token 列号按 UTF-16 code unit 计数，不会按 UTF-8 字节偏移漂移
references include-declaration parity 现在也有显式回归覆盖，锁住了 include_declaration = false 且仅存在定义位点时返回 Some(empty)（而不是 None）的桥接契约

已交付能力

ql check 已经是 parser + semantic + type 的统一入口
ql-analysis 成为 CLI / LSP / 未来 IDE 能力的共享分析层
qlsp 最小可用
UI diagnostics snapshot harness 已建立

关键 crate

crates/ql-diagnostics
crates/ql-analysis
crates/ql-hir
crates/ql-resolve
crates/ql-typeck
crates/ql-lsp

当前边界

P2 已经完成“语义地基”，但以下部分仍刻意未完成：

multi-segment unresolved global / unresolved type 的激进报错
module-path / ambiguous member 查询
ambiguous member completion
ambiguous method rename、从 shorthand field token 本身发起的 field-symbol rename，以及 cross-file rename
通用索引协议与更宽的 indexable type surface
更完整的类型推断、trait solving、effect checking、flow-sensitive narrowing
默认参数进入 AST / HIR / typeck

P3: MIR 与所有权分析地基

阶段目标

P3 的目标是让所有权、cleanup、drop、escape 这类后续高复杂度能力有稳定的中间表示和分析落点，而不是继续在 HIR/AST 上硬推。

切片进度

P3.1 Structural MIR Foundation

已完成：

新增 ql-mir
HIR -> MIR lowering
function body 的 stable local / block / statement / scope / cleanup ID
if / block tail / while / loop / break / continue 的 CFG lowering
defer 的 register / run-cleanup 显式表达
match / for / for await 保持结构化 terminator
ql mir <file> 可以直接渲染当前 MIR

这一刀的核心是建立“可解释、可扩展、可测试”的中端结构，而不是急着把所有控制流压扁。

P3.2 Ownership Facts 与显式 `move self`

已完成：

新增 ql-borrowck
MIR local 的 Unavailable / Available / Moved(certainty, origins) 状态
block entry / exit merge
read / write / consume 事件记录
direct local receiver 调用唯一匹配的 move self method 时，产出 use-after-move / maybe-moved diagnostics

这一步没有假装“borrow checker 已经完成”，而是先把 ownership facts 和第一类可信诊断做出来。

P3.3 Cleanup-aware ownership

已完成：

RunCleanup 真实参与 ownership analysis
deferred cleanup 按 LIFO 顺序执行
cleanup 中的 root local reassignment 可重新建立 Available
move self receiver 的消费时机调整到参数求值之后

这一步的价值是把 defer 从语法糖推进到真正影响 ownership 结果的分析面。

P3.3b Move closure capture ownership

已完成：

move closure 创建时消费当前 body 中被捕获的 direct local
普通 closure capture 作为真实 read 进入 ownership facts
ql ownership 可以展示 move closure capture consume 事件

P3.3c Explicit MIR closure capture facts

已完成：

closure capture facts materialize 到 Rvalue::Closure
ownership / debug 不再需要回头遍历 HIR 临时收集 capture 列表

P3.3d Closure escape groundwork

已完成：

MIR closure 稳定 identity
ql ownership 渲染 conservative may-escape facts
当前 escape kind 覆盖 return / call-arg / call-callee / captured-by-cl*

已交付能力

ql-analysis 已聚合 MIR 和 borrowck 结果
ql mir / ql ownership 已成为可用的调试入口
ownership diagnostics 已经有第一类真实用户可见结果

关键 crate

crates/ql-mir
crates/ql-borrowck
crates/ql-analysis

当前边界

P3 当前刻意未完成：

通用 call consume contract
place-sensitive move analysis
path-sensitive borrow / escape analysis
cleanup closure capture / nested defer runtime modeling
完整 closure environment / escape graph
drop elaboration
match / for 更低层 elaboration
完整 ownership diagnostics 体系

换句话说，P3 已经把“可继续做所有权系统”的地基打好，但还没有宣称“所有权系统完成”。

P4: LLVM 后端与原生产物地基

阶段目标

P4 的目标是把 MIR 真正接到原生产物链路上，同时把 driver / backend / toolchain / diagnostics / 测试的边界做稳。

切片进度

P4.1 Backend foundation

已完成：

新增 ql-driver
新增 ql-codegen-llvm
ql build 接入统一 build 路径
默认输出 LLVM IR：target/ql/<profile>/<stem>.ll
program mode / library mode 入口模型拆开
program mode 用户 main lower 成内部 Qlang entry + host main wrapper

这一刀解决的是“Qlang 有没有真正的后端入口”，不是“后端功能是否丰富”。

P4.2 Object emission

已完成：

ql build --emit obj
clang-style compiler toolchain discovery
compiler toolchain boundary 从 CLI 中抽离到 driver
toolchain failure 保留 .codegen.ll

P4.3 Executable emission

已完成：

ql build --emit exe
link failure 额外保留 .codegen.obj/.o
基础宿主 main wrapper 路径打通

P4.4 Static library emission

已完成：

ql build --emit staticlib
archive tool discovery 与 archiver boundary
staticlib 走 library mode，不再要求单文件库定义顶层 main
mock compiler + mock archiver 路径已经进入测试

P4.4b Dynamic library emission

已完成：

ql build --emit dylib
dylib 走 library mode，不再要求单文件库定义顶层 main
当前要求模块至少存在一个 public 顶层 extern "c" 函数定义，明确把 shared-library 输出约束在可解释的 C ABI surface 上
Windows 下会把这些 exported symbol 显式转成 /EXPORT:<symbol> 传给 linker
黑盒快照已经覆盖 dylib 成功路径与“无导出时拒绝构建”的失败路径

P4.5 Extern C direct-call foundation

已完成：

resolve / typeck / MIR / codegen 共享 callable identity
extern block member 不再被粗暴折叠成宿主 item
extern "c" direct call 会 lower 成 LLVM declare @symbol + call @symbol
program mode 和 library mode 两条路径都已打通
extern block declaration 和 top-level extern declaration 两种形态都已进入回归测试

这是 P4 当前最关键的一刀，因为它把“语言能否和宿主世界协作”推进到真实后端路径，而不是停留在语义层。

P4.6 Codegen golden harness 与失败模型

已完成：

crates/ql-cli/tests/codegen.rs
tests/codegen/pass/
tests/codegen/fail/
黑盒快照覆盖 llvm-ir / obj / exe / dylib / staticlib
增加 library-mode extern C direct-call lowering 快照
unsupported backend features 走结构化 diagnostics，而不是静默跳过
first-class function value 现在也会返回结构化 diagnostics，而不是 panic backend
deferred multi-segment source-backed type path 现在也有黑盒回归覆盖：backend unsupported diagnostics 会继续保留 Cmd.Scope.Config 这类源码路径文本，而不是把它误折叠成伪 concrete type
cleanup/defer lowering 仍未进入 P4 支持矩阵，但完全重复的 backend unsupported diagnostics 现在会被稳定去重；backend、driver 与 CLI 也已经补上这条 rejection contract 的显式回归

已交付能力

ql build 已经是可工作的后端入口
.ll / .obj / .exe / dylib / staticlib 路径都已经存在
toolchain failure model 与中间产物保留策略已建立
codegen regression harness 已建立

关键 crate

crates/ql-driver
crates/ql-codegen-llvm
crates/ql-cli

当前边界

P4 当前仍刻意未完成：

更完整的 LLVM / linker family 组合探测
runtime startup object / richer ABI glue
first-class function value lowering
closure / tuple / struct / cleanup lowering
一般化 shared-library surface、extern "c" export 的 visibility/linkage 控制与更完整 ABI surface
更大规模的 toolchain / lowering / fail snapshot 扩容

P5: C FFI 与宿主互操作地基

阶段目标

P5 的目标不是一次做完所有 FFI，而是先建立“Qlang <-> C 宿主”的最小可维护闭环，让导入、导出、头文件和真实宿主集成都有统一真相源。

切片进度

P5.1 Top-level `extern "c"` definition export

已完成：

顶层 extern "c" 函数定义允许保留 body
codegen 会为它们生成稳定导出符号
staticlib 已可直接承载这类导出

这一步把“语言能被 C 调用”从设计稿推进到真实产物层。

P5.2 Dynamic library emission

已完成：

ql build --emit dylib
shared-library 构建路径复用 library mode
当前要求模块至少有一个 public extern "c" 顶层定义，明确收敛在可解释的 C ABI surface 上
Windows 下显式补 /EXPORT:<symbol>，避免生成“看起来成功、实际上没有导出”的 DLL

P5.3 Minimal C header generation

已完成：

ql ffi header <file>
exported surface header 生成
默认输出 target/ql/ffi/<stem>.h
当前支持标量与指针的最小 C 类型映射
header 生成已经进入真实 FFI 集成链路，而不是停留在独立脚本
deferred multi-segment source-backed type path 现在也有显式回归覆盖：unsupported header-signature diagnostics 会继续保留源码路径文本，而不是把 Cmd.Scope.Config 误写成 same-file concrete type

P5.4 Import / both surface projection

已完成：

ql ffi header --surface exports|imports|both
import surface / combined surface 默认输出命名已稳定
extern block 成员和顶层 extern 声明可一起进入同一套头文件投影

P5.5 Build-side sidecar header

已完成：

ql build --emit staticlib|dylib --header
--header-surface
--header-output
sidecar header 和主产物使用同一份分析结果
若 sidecar 生成失败，会回滚刚生成的库产物，避免半成功状态

P5.6 Real C-host integration harness

已完成：

crates/ql-cli/tests/ffi.rs
static library linking smoke test
dynamic library runtime loading smoke test
imported-host callback harness
Rust static-link harness（经由稳定 C ABI 直接调用导出符号）
Rust static-link harness 也已覆盖最小宿主 callback 导入路径
Cargo-based Rust host smoke test（临时生成最小 Cargo 工程并链接 Qlang staticlib）
committed examples/ffi-c 示例工程与其自动化回归
committed examples/ffi-c-dylib 示例工程与其自动化回归
committed examples/ffi-rust 示例工程与其自动化回归
crates/ql-cli/tests/ffi.rs 已把 committed example smoke harness 收口为 table-driven case matrix；后续扩新的宿主工作流时优先只追加 case 数据，而不是复制新的 test body
crates/ql-cli/tests/support/ 已开始承接真实 smoke harness 的共享支持逻辑，当前先覆盖 ffi.rs 与 executable_examples.rs 的临时目录、产物路径、ql build 调用与文本规范化，后续扩覆盖面时优先复用该层而不是继续横向复制
crates/ql-cli/tests/support/ 现进一步承接宿主命令执行、退出码断言、产物存在断言与 stdout/stderr 断言；ffi.rs 与 executable_examples.rs 的真实 build-and-run smoke harness 已优先走同一套 helper，后续扩新的宿主矩阵时优先只补 case 与命令参数
crates/ql-cli/tests/ffi_header.rs 与 crates/ql-cli/tests/ui.rs 也已并入同一套 tests/support CLI harness helper；同时 tests/ui/type_invalid_assignment_target.stderr 已同步到当前能力面，不再继续把非 Task[...] 元素的 dynamic array assignment 误记为 unsupported
crates/ql-cli/tests/codegen.rs 的 build pass/fail snapshot harness 现也已切到同一套 tests/support CLI helper，保留 codegen 专用的 artifact/header 快照、target triple 渲染与 mock tool 包装逻辑；后续如果继续整理 ql-cli 集成测试，优先补共享 helper 而不是在单个测试文件里重复手写 ql build 过程
crates/ql-cli/tests/support/ 现继续承接快照读取、trim-end 标准化与统一 snapshot mismatch 文本；codegen.rs、ffi_header.rs、ui.rs 已优先复用该层，后续整理测试时优先补共享快照 helper 而不是在各文件里重复手写 read_to_string + normalize + diff 组合
header-surface metadata 驱动的 FFI fixture

已交付能力

Qlang 已经能通过最小 C ABI surface 被宿主调用
Qlang 也已经能声明和调用外部 C ABI 函数
ql ffi header 与 ql build --header 已经建立真实工具链闭环
静态库 / 动态库 + 头文件 + C 宿主测试已经形成可信最小链路

关键 crate

crates/ql-driver
crates/ql-cli
crates/ql-codegen-llvm

当前边界

P5 当前仍刻意未完成：

struct / tuple / enum 的稳定 C ABI 建模
更完整的布局诊断与 ABI 兼容诊断
C++ 直接绑定生成
Rust-specific wrapper 生成
自动安全包装和 richer FFI ergonomics
复杂 runtime / ownership 穿边界语义

P6: LSP 与编辑器语义收口

阶段目标

P6 的目标不是把 IDE 能力一次做成“跨项目完整版”，而是在既有 same-file 分析边界上，把 query、rename、completion、semantic tokens 和 LSP bridge 收敛成一套稳定 truth surface。

切片进度

P6.1 Query truth surface 加固

已完成：

same-file references / hover / definition 的真相源固定到 QueryIndex
direct symbol surface、direct member surface、callable surface、type-namespace surface 都补上显式 parity 回归
import alias、same-file local import alias -> local struct/enum item 的 follow-through 被统一收敛到 analysis/query 边界

P6.2 Same-file rename 收口

已完成：

prepare_rename_at
rename_at
LSP prepareRename / rename
同文件 rename 现在覆盖 function / const / static / struct / enum / trait / type alias / import / field / method（唯一候选）/ local / parameter / generic / variant
shorthand binding / shorthand field 的 rewrite 规则已进入稳定回归

P6.3 Completion 收口

已完成：

lexical value completion
type-context completion
stable receiver member completion
parsed enum variant-path completion
import alias variant / struct-variant completion follow-through
escaped identifier completion insert text 保真
candidate-list parity 与 filtering parity 已锁定

P6.4 Semantic tokens 与桥接一致性

已完成：

same-file semantic tokens
analysis occurrence -> LSP legend 的稳定映射
direct symbol/member、callable、type-namespace、import alias、variant 等 surface 都补上 semantic-token parity 回归

P6.5 Editor-facing aggregate hardening

已完成：

callable / direct symbol / direct member / type namespace / value candidate / variant candidate 等 aggregate surface 回归
impl-preferred member filtering
lexical visibility / shadowing consistency
analysis / LSP 两层结果顺序、detail、text edit 投影一致性

已交付能力

qlsp 现在已经具备可信的 same-file diagnostics / hover / definition / references / completion / semantic tokens / prepare-rename / rename
ql-analysis 已经成为 CLI 和 LSP 共用的 editor semantics 边界
import alias、field、variant、method、type namespace 等易漂移 surface 已经被系统性回归锁住

关键 crate

crates/ql-analysis
crates/ql-lsp
crates/ql-resolve
crates/ql-typeck

当前边界

P6 当前仍刻意未完成：

cross-file / workspace 索引
parse-error tolerant dot-trigger completion
module graph deeper completion / navigation
ambiguous member completion 和 ambiguous method rename
从 shorthand field token 本身发起 field-symbol rename 的完整 editor semantics
code actions / inlay hints / call hierarchy / project-wide rename

P7: 并发、异步与 Rust 互操作（进行中）

当前范围

先收口语义层与诊断层，不直接跳到 runtime/codegen 大改
保持 conservative 策略，避免过早承诺完整 effect/Future 类型系统

本轮已完成

ql-typeck 已新增函数级 async 上下文
await / spawn 在非 async fn 内使用会给出显式 diagnostics
新增 crates/ql-typeck/tests/async_typing.rs，锁住边界行为
ql-resolve 新增 async 语义查询契约：expr_is_in_async_function / scope_is_in_async_function
ql-analysis 新增 async_context_at（await / spawn / for await -> 是否处于 async 函数上下文）
新增 ql-analysis async 查询回归测试，锁住查询语义
ql-lsp bridge 新增 async_context_for_analysis 只读桥接（位置 -> async 运算符上下文）
新增 ql-lsp async 桥接回归测试，锁住 bridge 行为
ql-analysis / ql-lsp async 查询桥接已覆盖 for await 运算符上下文（当前锚定 await 关键字 span）
ql-resolve / ql-typeck / ql-analysis / ql-lsp 新增 trait / impl / extend 方法面的 async 回归：锁住方法体内 await / spawn / for await 的边界与查询语义
ql-typeck 新增 for await 的 async 上下文约束（非 async fn 显式诊断）
新增 ql-typeck 的 for await 边界回归测试
ql-typeck 新增 await / spawn 操作数形态约束：当前要求操作数必须是 call expression
新增 ql-typeck 的 await / spawn 非调用操作数回归测试
ql-typeck 进一步收紧 await / spawn 的调用目标约束：当前不仅要求 operand 是 call expression，还要求被调用目标来自 async fn；同步函数、sync 方法和普通 closure/callable 值调用都会给出显式诊断
新增 ql-typeck 的 async-call-target 回归测试，覆盖 sync function / async function / method / closure callable 这几类 operand
ql-resolve / ql-typeck / ql-analysis / ql-lsp 新增 closure async 边界回归：closure body 当前不会继承外层 async fn 语义上下文
ql-typeck 新增 closure block 显式 return 回归：当 closure 有期望 callable 返回类型时，显式 return 会按 callable 签名检查；内层 nested closure 的 return 不会污染外层 closure 返回推断
ql-typeck 新增保守 return-path 收口：函数与 closure body 现在会拒绝“部分路径 return、部分路径 fallthrough”的情形；if 与最小穷尽性 match（_、Bool true/false、enum 全 variant）已进入 all-path return 推断；带 guard 的 arm 默认仍保守，只有显式字面量 true guard 会计入覆盖
ql-typeck 已把显式常量条件的 if 纳入 must-return 收口：if true { return ... }、if false { ... } else { return ... } 与 closure 中同构写法现在会被接受；if false { return ... } 仍不会被误判成保证返回
ql-typeck 已把显式字面量 Bool scrutinee 的 match 纳入 must-return 收口：match true/false 会按 arm 顺序和字面量 guard 做保守裁剪；无可达 arm 或被字面量 false guard 挡住的唯一 arm 仍不会被误判成保证返回
ql-typeck 已把非字面量 Bool / enum match 的字面量 guard 收口到有序 arm 流分析：true if true、false if true、_ if true 和 enum variant if true 现在会参与穷尽性与 must-return 推断；未知 guard 仍保持保守，不会提前裁掉后续 arm
ql-typeck 新增 loop-control 语义约束：break / continue 在非 loop body 中会给出显式诊断；closure body 不会继承外层 loop-control 上下文
ql-typeck 已把 must-return 收口提升到有序控制流摘要：loop { return ... } 现在会被接受；break; return ... 与“无 break 的 loop 之后再写 return”这类不可达路径不会再被误判成保证返回；更深层表达式子节点也按求值顺序参与保守 return 分析
ql-typeck 已把显式常量条件的 while 纳入 must-return 收口：while true { return ... } 与 closure 中同构写法现在会被接受；while true 中的 break; return ... 和 while false { return ... } 仍不会被误判成保证返回
ql-analysis / ql-lsp 已补上 loop-control 查询桥接：break / continue 现在可以像 async operator 一样通过只读分析接口查询当前位置是否位于 loop body，closure body 仍会重置外层 loop 上下文
ql-driver / ql-cli 已把 llvm-ir / obj 下的当前 async program 子集纳入用户可见回归：async fn main 及其已支持的 await / spawn / fixed-array for await 路径现在可以稳定产出 LLVM IR 或对象文件，而更广义未开放 async surface 仍保持显式拒绝
ql-cli codegen 黑盒快照现已补上 async_program_main_llvm_ir、async_program_main_spawn_bound_task_handle_llvm_ir 与 async_program_main_for_await_array_llvm_ir，锁住终端侧 ql build --emit llvm-ir 的当前 async program 子集成功输出
ql-driver / ql-cli 已把 dylib 打开首个 async library 子集：带内部 async helper 的动态库现在可以在存在同步 extern "c" 顶层导出时通过，而公开 C header surface 仍只暴露同步导出，不泄露 worker / helper 这类 async implementation details
ql-driver 新增 cleanup + async 混合诊断回归：同一文件里同时出现 defer 和 async fn 时，cleanup lowering 失败与 async fn unsupported 现在都会各自稳定只出现一次，不再互相吞掉或额外放大
ql-driver / ql-codegen-llvm 新增 cleanup + for await 混合诊断回归：同一文件里同时出现 defer 与 for await 时，cleanup lowering 失败与 for await unsupported 现在都会各自稳定只出现一次，不再互相吞掉或额外放大
ql-driver / ql-codegen-llvm 新增 cleanup + for 混合诊断回归：同一文件里同时出现 defer 与 for 时，cleanup lowering 失败与 for unsupported 现在都会各自稳定只出现一次，不再互相吞掉或额外放大
ql-driver / ql-codegen-llvm / ql-cli 新增 cleanup + for CLI fail snapshot：用户可见 stderr 现在也稳定只出现 cleanup lowering 失败与 for unsupported 两条主诊断，不再额外级联 backend noise
ql-driver / ql-codegen-llvm / ql-cli 新增 cleanup + match 混合诊断回归：同一文件里同时出现 defer 与 match 时，cleanup lowering 失败与 match unsupported 以及现有的 match elaboration / pattern diagnostics 现在都会稳定只出现一次，不再额外放大 backend noise
ql-driver / ql-codegen-llvm / ql-cli 新增 match + ? 混合诊断回归：同一文件里同时出现 helper match 与 main ? 时，match lowering、pattern diagnostics 与 ? unsupported 现在都会稳定只出现一次，不再额外放大 backend noise
ql-driver / ql-codegen-llvm / ql-cli 新增 cleanup + ? 混合诊断回归：同一文件里同时出现 defer 与 ? 时，cleanup lowering 失败与 ? unsupported 现在都会稳定只出现一次，不再额外级联 MIR elaboration noise
ql-driver / ql-codegen-llvm / ql-cli 新增 cleanup + closure value 混合诊断回归：同一文件里同时出现 defer 与 closure 值时，cleanup lowering 失败与 closure value unsupported 现在都会稳定只出现一次，不再额外级联 backend noise
ql-driver / ql-cli 新增 async + generic 并存回归：锁住多条 backend unsupported 诊断的聚合稳定性
ql-driver / ql-cli 新增 async + unsafe fn body 并存回归：锁住签名级多条 backend unsupported 诊断的聚合稳定性与终端输出
ql-codegen-llvm / ql-driver / ql-cli 新增结构化 MIR terminator 的 backend 拒绝回归：match lowering unsupported 与 for lowering unsupported 现在都有后端单测、driver 回归和 CLI 失败快照覆盖
ql-codegen-llvm / ql-driver / ql-cli 进一步清理 backend 失败合同噪声：当 closure value、match lowering、for lowering 已经明确 unsupported 时，不再继续级联产出 _t0 local-type 推导噪声，CLI 快照现在更接近真实主失败原因
ql-mir 新增 async operator lowering 回归：await / spawn 当前会作为显式 unary rvalue 保留在 MIR 中，并消费前面物化出来的 call 结果；same-file import alias 的 async call 也会继续保留 Import callee，而不是退化成 opaque/unresolved operand
ql-cli FFI 集成测试已补上最小 Rust host 静态链接回归：Rust harness 现在既可以直接链接 Qlang staticlib 调用导出函数，也可以为 Qlang 的 extern "c" import 提供 callback，实现最保守的双向互操作
ql-cli FFI 集成测试进一步补上 Cargo-based Rust host smoke test：测试会临时生成最小 Cargo 工程并通过 build.rs 链接 Qlang staticlib，让当前 Rust 混编路径更接近真实项目工作流
仓库已提交 examples/ffi-c：真实 C host 通过 ql build --emit staticlib --header-surface both 生成 combined header 与静态库，并在 ql-cli FFI 集成测试中回归锁住该示例的可运行性
仓库已提交 examples/ffi-c-dylib：真实 C host 通过 runtime loader 加载 ql build --emit dylib 产物，并在 ql-cli FFI 集成测试中回归锁住 shared-library 工作流；示例源码还显式保留 internal async fn + fixed-array for await，用于展示当前“公开 C ABI 仍同步、内部 async library body 可存在”的最小 async dylib 子集
仓库已提交 examples/ffi-rust：真实 Cargo host 通过 build.rs 编译 sibling Qlang 源码并链接 staticlib，同时 ql-cli FFI 集成测试也已回归锁住该示例的可运行性
新增 crates/ql-runtime：当前仓库已有最小 runtime/executor 抽象地基，提供 Task / JoinHandle / Executor trait 和单线程 InlineExecutor
crates/ql-runtime/tests/executor.rs 已锁住 run-to-completion、spawn + join、block_on 与单线程执行顺序
crates/ql-runtime 已固定第一批稳定 capability 名称：async-function-bodies、task-spawn、task-await、async-iteration
crates/ql-runtime 已起草第一版共享 runtime hook ABI skeleton：当前固定 async-frame-alloc、async-task-create、executor-spawn、task-await、task-result-release、async-iter-next 及对应稳定符号名，并给出统一 ccc + opaque ptr 的第一版 LLVM-facing contract string
ql-analysis 已暴露 runtime_requirements()，按源码顺序枚举当前 async surface 对应的 runtime 需求，并补上 operator span / declaration-vs-definition 边界回归
ql-cli 已扩展 ql runtime <file>，现在会同时输出 runtime capability 需求和 dedupe 后的 runtime hook 计划，作为后续 runtime/codegen 接线前的开发者可见检查面
ql-driver 已开始保守消费这份 runtime requirement surface：当前会把 async-function-bodies、task-spawn、task-await、async-iteration 映射成稳定的 build-time unsupported 诊断，并与 backend 同类 diagnostics 去重，锁住 driver/codegen 边界的拒绝合同
ql-codegen-llvm 已开始直接消费共享 runtime hook ABI signatures：后端输入现在可携带 dedupe 后的 hook 列表，并渲染稳定的 LLVM declare 语句，避免 backend 自己复制 hook 名称或 ABI 字符串
ql-codegen-llvm 现已把 body-bearing async fn 再推进一步：backend 会统一生成 ptr frame 形态的真实 body symbol（__async_body）、负责把 typed return heap-materialize 成 opaque result ptr 的 __async_entry thunk，以及对外 task-create wrapper；带参数的 async fn 继续通过 qlrt_async_frame_alloc materialize 最小 heap frame，再交给 qlrt_async_task_create，不再把 typed body 直接暴露给 runtime hook
ql-codegen-llvm / ql-driver 现也会为 BuildEmit::DynamicLibrary 内联最小 runtime hook 定义：library-mode async dylib 不再只停留在 mock-toolchain 成功，而是能在真实工具链下把 qlrt_async_task_create / qlrt_task_await / qlrt_task_result_release / qlrt_async_iter_next 一并打进共享库，自包含链接当前受支持的 async library body 子集
ql-codegen-llvm / ql-driver / ql-cli 已把 for await 打开首个 library-mode lowering 竖切片：staticlib async library body 内对 fixed array iterable 的 for await 现在会稳定进入 backend，并通过 index-slot + array-element load 的最小 IR 形态驱动 loop item binding；非 array iterable 与非 staticlib build surface 仍保持稳定 unsupported
ql-runtime / ql-cli / ql-codegen-llvm 已补上 task-result transport 的第一条 ABI skeleton：task-await capability 现在会同时暴露 qlrt_task_await(handle: ptr) -> ptr 与 qlrt_task_result_release(result: ptr) -> void，并明确当前 backend 直接把 fresh task handle 与 spawn-returned handle 视作同一 awaitable opaque handle 形态，先把“等待得到 opaque result ptr”与“释放 result payload”这两个动作拆开冻结合同，再决定后续 typed extraction lowering
ql-codegen-llvm 已补上 AsyncTaskResultLayout 内部抽象：当前 async 结果已接受 Void、scalar builtin，以及递归可加载的 tuple / fixed array / 非泛型 struct，并在 signature 阶段锁定 payload 的 LLVM type/size/align，避免后续 await lowering 再反过来重写 async wrapper/result 合同
ql-codegen-llvm 已把 parameterized async fn wrapper 的 frame layout 扩到递归可加载 aggregate 参数：tuple / fixed array / 非泛型 struct 参数现在可被写入 heap frame，并在 __async_body 内按相同布局回读
ql-codegen-llvm 已打开首个真实 await lowering：当前在 backend 内支持 Void / scalar builtin / recursively loadable aggregate async 结果，并把 await 降成 qlrt_task_await + load payload + qlrt_task_result_release 的最小链路；BuildEmit::Executable program-mode 现在还会在模块内定义最小 runtime hook 集合与 qlrt_async_iter_next stub，因此当前受支持的 async executable 子集已不再只是“IR 生命周期可生成”，而是可以直接链接并运行
ql-codegen-llvm 已打开首个真实 spawn lowering 子集：当前 backend 支持把 task-handle operand 降成 qlrt_executor_spawn(ptr null, task)，并返回可继续 await 的 task handle；当前已覆盖 direct async call、局部绑定 handle 与 sync helper 返回 handle，statement-position fire-and-forget 只是丢弃该返回句柄的特例
ql-codegen-llvm 已把最小 place projection lowering 扩到写路径：当前嵌套 struct field read、constant tuple index read、array index read 继续走统一 place/type 推导与 LLVM GEP 链 lowering，而 struct-field write、constant tuple-index write，以及非 Task[...] 元素的 dynamic fixed-array index write 也已复用同一条 lowering；Task[...] 动态数组元素赋值现也已打开首条保守 write-only 子集：tasks[index] = worker() 会进入同一条 projection pointer lowering，但仍不把 dynamic index 误当成 precise reinit
ql-codegen-llvm / ql-driver / ql-cli 已打开 projected task-handle operand 支持：当投影结果本身是 Task[T] 时，await pair[0]、spawn pair[0]、await tasks[0]、spawn tasks[0]、await pair.task 与 spawn pair.task 现在都能稳定进入 codegen 与 staticlib 路径；这条支持目前已有 tuple、fixed-array literal index 与 struct-field 的端到端回归覆盖
ql-typeck / ql-borrowck / ql-codegen-llvm / ql-driver 已打开最小 projection write/reinit 切片：mutable root 下的 pair[0] = ...、pair.left = ... 与 tasks[0] = ... 现在会在 typeck 层稳定放行、在 borrowck 层按 projection path 清除已消费的 task-handle move 记录、在 codegen 层生成写入 projection pointer 的 store；同时非 Task[...] 元素的 dynamic array assignment 也已进入这条最小写路径，补齐普通数组 values[index] = ... 与 nested matrix[row][col] = ... 的端到端能力，并在 ql-driver 内部单测与 ql-cli 黑盒 fixture 层锁定；Task[...] 动态数组元素赋值现也已从首条 write-only 子集继续推进：generic dynamic tasks[index] = worker() 仍只保守降级 overlap，而 same immutable stable index path（例如 index、slot.value）以及可折回同一 literal path 的 same-file const item（例如 INDEX、SLOT.value）现也可精确恢复同一路径的 consumed task handle
ql-codegen-llvm / ql-driver / ql-cli 现也已把 generic dynamic task-handle array 的 user-facing build matrix 显式锁定：tasks[index] = worker() 这条 generic dynamic assignment 路径，以及 let running = spawn pending.tasks[index]; await pending.fallback 这条 sibling-safe dynamic consume/spawn 路径，现在都已有 staticlib async helper 与 BuildEmit::Executable async fn main() 两类成功构建回归，不再只停留在内部 unit-test coverage；本轮又把 projected-root reinit（pending.tasks[slot.value] = ...）与 projected-root const-backed literal reuse（await pending.tasks[INDEX]; await pending.tasks[0]）补进了 driver/CLI 的定向矩阵
ql-borrowck 现也已把最小 immutable const-backed index alias 折回 fixed-array literal path：let index = 0; await tasks[index]; await tasks[0] 与 let slot = Slot { value: 0 }; await tasks[slot.value]; await tasks[0] 这类路径现在都会落到 literal-index overlap，因此 reuse 会稳定报 definite use-after-move，而同一路径重初始化后再读 tasks[0] 也可恢复通过
ql-borrowck / ql-driver 现也已把 same immutable source alias 纳入 dynamic task-handle index 归一化：let alias = index; await tasks[alias]; await tasks[index] 与 let slot = Slot { value: index }; await tasks[slot.value]; tasks[index] = worker(); await tasks[slot.value] 这类“不同写法但同一 immutable source path”的路径现在会落到同一 stable dynamic path，因此跨别名 reuse 会稳定报 definite use-after-move，而跨别名 reinit 也可恢复通过
ql-borrowck / ql-driver / ql-cli 现也已把 composed stable dynamic source path 纳入同一套归一化：当 dynamic index 本身来自另一个稳定 dynamic path（例如 let slots = [row, row]; await tasks[slots[row]]; tasks[slots[row]] = worker(); await tasks[slots[row]]）时，borrowck 不再把它退回 generic maybe-overlap，而会沿用现有 stable-dynamic path overlap 结果，因此同路径重复消费会稳定报 definite use-after-move，同路径 reinit 也会恢复通过，并已在 staticlib / async fn main() 的用户可见构建矩阵中锁定
ql-borrowck / ql-driver / ql-cli 现也已把 alias-sourced composed dynamic source path 纳入同一套归一化：当 composed dynamic source path 先经 immutable alias 重新绑定（例如 let slots = [row, row]; let alias = slots; await tasks[alias[row]]; await tasks[slots[row]]）时，borrowck 不再把 alias[row] 与 slots[row] 视为 generic maybe-overlap，而会继续回到同一条 stable-dynamic path，因此跨源路径 reuse 会稳定报 definite use-after-move，跨源路径 reinit 也会恢复通过，并已补进 staticlib / async fn main() 的用户可见回归矩阵
ql-borrowck / ql-driver / ql-cli 现又补上最小 equality-guard dynamic-index refinement：当 if index == 0 或 if slot.value == 0 这类条件把 stable dynamic source path 收窄到具体元素时，borrowck 会在 dominated branch 内把 tasks[index] / tasks[slot.value] 回收到 tasks[0] 这条 literal/projection path，因此 guarded literal reuse 会稳定报 definite use-after-move，而 guarded tasks[0] = worker() / projected tasks[0] = worker() 也可恢复通过；对应的 staticlib build、CLI fixture，以及 async fn main 下 direct projected slot.value == 0 与 helper-based direct index == 0 两类 llvm-ir / obj / exe program build matrix 现都已同步锁定，避免这条 guard-sensitive 精度只停留在内部 ownership 单测
ql-borrowck 现也已把这条 guard refinement 延伸到 deferred cleanup：defer if index == 0 { forward(tasks[index]) } else { ... } 与 projected slot.value 版本现在会在 cleanup then-branch 内回收到 tasks[0]，并且会结合外层 index != 0 / slot.value != 0 路径留下的排除事实来裁掉不可能分支，因此 tasks[0] = worker() 后的 cleanup 不再误报 use-after-move；ql-driver / ql-cli 目前锁定的是更准确的用户可见边界，即这类程序现在只会停在现有的 cleanup lowering unsupported 诊断，而不再夹带 borrowck 误报
ql-borrowck / ql-driver / ql-cli 现也已把 task-handle root alias canonicalization 补进同一条生命周期边界：当 let alias = task、let alias = tasks 或 let alias = pending.tasks 这类 immutable alias 只是重新绑定同一条 task-handle root/source path 时，await alias / await alias[index] 会继续记到原 source local/path 上，而不会伪造一份独立 alias local 生命周期；因此 await alias; await task / await alias[index]; await tasks[index] 现在都会稳定报 source-root definite use-after-move，而通过 task = worker() / pending.tasks[index] = worker() 对 source root 的重初始化也会恢复 await alias / await alias[index] 的可用性
同一条 task-handle root alias canonicalization 现也已进入普通 read/aggregate 构造路径：let pair = (alias, worker())、let pair = (alias[index], worker()) 这类 alias-fed tuple/aggregate repackage 现在不会再把已移动的 task handle 偷偷重新包装成新的 aggregate payload，而会在 alias read 处继续报 source-root use-after-move；若 source root 已先通过 task = worker() / pending.tasks[index] = worker() 重初始化，则同样的 aggregate repackage 会恢复通过
ql-borrowck / ql-codegen-llvm / ql-driver / ql-cli 现也已把 projected dynamic task-handle index 的 branch-join reinit 明确锁进用户可见矩阵：if flag { let first = await tasks[slot.value]; tasks[slot.value] = worker() } await tasks[slot.value] 这类 same immutable projected dynamic index 路径现在已有前端事实回归、program-mode codegen 单测、driver executable/staticlib 成功构建回归，以及 CLI 定向 pass cases，避免这条“实现已开但此前未显式黑盒锁定”的路径在后续收口里静默回退；本轮又确认相同语义在 aggregate field root 下同样成立，即 pending.tasks[slot.value] 的 reinit 与 pending.tasks[INDEX] 的 const-backed literal reuse 也已进入 borrowck / driver / CLI 的定向覆盖
ql-typeck / ql-borrowck / ql-driver / ql-cli 现也已补上 fixed-array literal-index projected task-handle reinit 的 branch-join 正向回归：if flag { let first = await tasks[0]; tasks[0] = worker() } return await tasks[0] 这类条件性重初始化路径现在在前端、borrowck、driver 与 CLI 黑盒层都有定向覆盖，避免这条刚开放的 write/reinit 子集在后续收口里静默回退
ql-codegen-llvm 已补上 empty-array expected-context lowering：当前会把具体 [T; N] 期望类型保守回传到 direct temp locals 与 tuple / array / struct 聚合字面量内部，因此 return []、take([])、([], 1)、Wrap { values: [] } 与 [[]] 这类已有 [T; 0] 上下文的路径现在都可稳定出 IR；没有期望数组类型的裸 [] 仍保持显式拒绝
ql-codegen-llvm / ql-driver / ql-cli 已锁住 zero-sized async parameter 回归：[Int; 0]、Wrap { values: [Int; 0] } 与 [[Int; 0]; 1] 这类 zero-sized aggregate 参数现在稳定走递归可加载 frame lowering，await 与 staticlib 路径都已被定向测试覆盖
ql-codegen-llvm / ql-driver / ql-cli 已锁住 zero-sized async result 回归：[Int; 0] 与只包含 zero-sized fixed-array 字段的递归 aggregate 现在仍按 loadable async result 处理，direct await、direct/bound spawn 后再 await、helper direct/bound await、helper local-return task / helper-forward Task[Wrap] 流动，以及 spawn schedule() / let task = schedule(); let running = spawn task; await running / spawn forward(task) 这类 helper task-handle 路径都已被定向测试覆盖
ql-typeck / ql-borrowck / ql-codegen-llvm / ql-driver / ql-cli 已把嵌套 task-result payload 收进口径：async fn outer() -> Task[Int] 与 async fn outer() -> Task[Wrap]（其中 Wrap 仅含 zero-sized fixed-array 字段）现在都可稳定走 let next = await outer(); await next 这条 chained-await 路径，类型层会把第一次 await 结果继续视为 fresh task handle，borrowck 会继续对该新句柄做 consume/use-after-move 跟踪，staticlib codegen/driver/CLI 也已有端到端回归锁定
ql-typeck / ql-borrowck / ql-codegen-llvm / ql-driver / ql-cli 现也已锁住 aggregate-carried task-handle payload：async fn outer() -> (Task[Int], Task[Int])、async fn outer() -> [Task[Int]; 2]、带 Task[Wrap] 字段的 struct 结果，以及 [Pending; 2] 且 Pending { task: Task[Int], value: Int } 这类递归 nested fixed-shape aggregate 结果，现在都可先 await outer() 得到 aggregate，再通过 await pair[0] / await pair[1]、await tasks[0] / await tasks[1]、await pending.first / await pending.second、await pending[0].task / await pending[1].task 继续消费内部 task handle；这说明当前 loadable result contract 已覆盖“递归 nested fixed-shape aggregate payload 内继续携带 task handle 并走后续 projection await”这条受控子集
ql-typeck / ql-borrowck 现也已显式镜像 zero-sized helper Task[Wrap] 流动回归：await schedule()、spawn schedule()、local-return helper、bound spawn 后再 await、helper Task[Wrap] 参数传递、conditional helper return、conditional maybe-moved 分支、branch-join maybe-moved 分支、branch-join helper consume/reinit 分支、branch-join spawned reinit 分支、reverse-branch spawned reinit 分支、helper 内条件性 spawn-return 分支、helper-consumed 后重赋值可恢复的路径、deferred cleanup 重初始化后继续读取的路径、deferred cleanup helper-consume use-after-move、conditional cleanup maybe-moved 分支、conditional cleanup helper-consume maybe-moved 分支、conditional cleanup 重初始化路径、conditional cleanup 重初始化并消费路径、conditional cleanup 重初始化并 helper-consume use-after-move 路径、reverse-branch conditional cleanup helper-consume/reinit 路径、以及对应的 borrowck debug render 事实，现在都有前端层专门测试，不再只依赖 backend/staticlib 黑盒覆盖；当前新增的 helper 条件分支回归专门锁住的是 async helper 内条件性 spawn 后再 await 返回的 zero-sized Task[Wrap] 结果流，以及直接 async 调用条件分支与 branch-join spawn reinit 的同类 flow，并且这些路径现在也已在 codegen / driver 的 staticlib 路径上补齐端到端回归
ql-typeck / ql-borrowck 还补上了无 cleanup 的 branch-join helper consume/reinit 回归：if flag { forward(task) } else { task = fresh_worker() } 这类 zero-sized Task[Wrap] flow 现在会在 typeck 层稳定放行、在 borrowck 层稳定报出 local \task` may have been moved on another control-flow path；ql-driver` 也已补上对应的稳定失败合同，继续补齐 task-handle 的控制流边界
ql-driver 已开放第一条 public async build 子集：staticlib 现在允许已被 backend 支持的 async library body、当前最小 match lowering、scalar/task-handle/tuple/array/struct/void await、以及可绑定后再 await 的 spawn task handle 通过；fixed array iterable 的 for await 也已进入这条受控 library-mode 子集，而 broader async iteration surface 仍保持关闭
ql-driver / ql-cli 已开放最小 async dylib 子集：只要模块仍提供同步 extern "c" 顶层导出，内部 async helper、当前最小 match lowering、await、已支持的 task-handle lowering，以及 fixed-array iterable 的 for await 现在都可进入 dylib 构建；非数组 iterable 与更广义 async surface 仍保持显式 unsupported
ql-cli/tests/codegen.rs 现已把 aggregate param/result family 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_aggregate_param_result_families.ql 与 fixtures/codegen/pass/ffi_export_async_aggregate_param_result_families.ql，并用这对 family fixture 合并掉此前分散的 async_library_recursive_aggregate_params.ql、async_library_zero_sized_aggregate_results.ql、async_library_zero_sized_aggregate_params.ql 三条 staticlib only case；当前显式覆盖 recursive aggregate 参数、zero-sized array/struct result，以及 zero-sized aggregate 参数在两条 library build surface 上的对称成功构建合同
ql-cli/tests/codegen.rs 现已把 async library match family 的 library-mode public contract 锁进 staticlib / dylib：fixtures/codegen/pass/async_library_match_families.ql 与 fixtures/codegen/pass/ffi_export_async_match_families.ql 现已在同一对 fixture 里显式覆盖 awaited scalar scrutinee + direct-call guard、awaited aggregate scrutinee + projection guard、awaited aggregate scrutinee + aggregate guard-call arg / call-backed aggregate guard-call arg、same-file import-alias rooted awaited helper / guard helper variants、awaited scrutinee + item/import-alias-backed inline guard combos、awaited scrutinee + direct call-backed guard combos、awaited scrutinee + inline aggregate guard-call arg combos、awaited scrutinee + inline projection-root guard combos、awaited scalar scrutinee + nested call-root runtime projection guard variants、awaited scalar scrutinee + nested call-root inline projection/inline aggregate guard-call combos、awaited scrutinee + item-backed nested call-root guard variants、awaited scrutinee + call-backed nested call-root guard variants、awaited scrutinee + alias-backed nested call-root guard variants，以及 awaited aggregate current-binding / read-only projection-root backed nested call-root guard variants，说明当前 library async 子集已能稳定承载既有最小 match lowering 在 async helper body 内的更完整成功构建路径，而不再只公开 await / spawn / for await
ql-cli/tests/codegen.rs 现已把 aggregate await / projected spawn family 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_aggregate_await_families.ql 与 fixtures/codegen/pass/ffi_export_async_aggregate_await_families.ql，在同一对 fixture 里显式覆盖 scalar/tuple/struct/array/nested aggregate await，tuple projection await|spawn，zero-sized task-array projection await，以及 struct-field projection await|spawn；此前零散的 async_library_scalar_await.ql、async_library_tuple_await.ql、async_library_struct_await.ql、async_library_array_await.ql、async_library_nested_aggregate_await.ql、async_library_projected_tuple_await.ql、async_library_projected_tuple_spawn.ql、async_library_projected_array_await.ql、async_library_projected_struct_field_await.ql、async_library_projected_struct_field_spawn.ql 已被 family 吸收删除，说明当前 library async 子集已能稳定承载一整片 aggregate await / projected submit surface，而不再只依赖零散 staticlib success case
ql-cli/tests/codegen.rs 现已把 aggregate-carried / nested task-handle payload family 的 library-mode public contract 锁进 staticlib / dylib：fixtures/codegen/pass/async_library_task_handle_payload_families.ql 与 fixtures/codegen/pass/ffi_export_async_task_handle_payload_families.ql 现在已在同一对 fixture 里显式覆盖 task-array payload、task-tuple payload、nested aggregate task field payload 与 chained Task[Wrap] result；此前单点的 async_library_task_handle_tuple_payload.ql、async_library_task_handle_array_payload.ql、async_library_nested_aggregate_task_handle_payload.ql 与更早的 async_library_nested_task_handle.ql 已被 family 吸收删除，说明当前 library async 子集已能稳定承载 aggregate-carried task-handle payload，而不再只停留在 flow/path 级别合同
ql-cli/tests/codegen.rs 现已把 direct/helper task-handle flow family 的 library-mode public contract 锁进 staticlib / dylib：fixtures/codegen/pass/async_library_task_handle_flow_families.ql 与 fixtures/codegen/pass/ffi_export_async_task_handle_flow_families.ql 现在已在同一对 fixture 里显式覆盖 direct call、direct local handle、helper-returned、helper-bound、local-return、forwarded 这组 await 路径，以及 direct call、direct-bound、helper、helper-bound、forwarded 这组 spawn -> await 路径，并同时覆盖 Task[Int] 与 zero-sized Task[Wrap]；此前零散的 async_library_task_handle*.ql、async_library_*zero_sized_task_handle.ql、async_library_direct_handle.ql 与对应的 spawn_*task_handle.ql 单点 fixture 已被 family 吸收删除，说明当前 library async 子集已能稳定承载最常见的 task-handle flow，而不再只依赖少量离散样例
ql-cli/tests/codegen.rs 现已把 stable-dynamic task-handle 成功路径的 library-mode public contract 锁进 staticlib / dylib：fixtures/codegen/pass/async_library_dynamic_task_handle_paths.ql 与 fixtures/codegen/pass/ffi_export_async_dynamic_task_handle_paths.ql 现在已在同一对 fixture 里显式覆盖 projected/aliased/composed/guard-refined dynamic reinit、generic dynamic array assignment，以及 dynamic sibling-safe spawn 路径；此前零散的 async_library_dynamic_task_handle_array_assignment.ql、async_library_dynamic_task_handle_spawn_sibling.ql、async_library_composed_dynamic_task_handle_reinit.ql 与 async_library_alias_sourced_composed_dynamic_task_handle_reinit.ql 已被 family 吸收删除，说明当前 library async 子集已能直接消费更完整的稳定动态 task-handle path，而不再只局限于 literal/projection path
ql-cli/tests/codegen.rs 现已把 aliased projected-root repackage family 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_aliased_projected_root_repackage_families.ql 与 fixtures/codegen/pass/ffi_export_async_aliased_projected_root_repackage_families.ql，在同一对 fixture 里显式覆盖 source-root reinit 之后经 tuple、struct 与 nested aggregate 重新包装的 task-handle await 路径；此前零散的 async_library_aliased_projected_root_task_handle_tuple_repackage_reinit.ql 与已被 dynamic family 吸收的 async_library_aliased_projected_root_dynamic_task_handle_reinit.ql 也已删除，说明当前 library async 子集已能稳定承载 alias-root aggregate repackage，而不再只停留在 async program public contract
ql-cli/tests/codegen.rs 现已把 aliased projected-root spawn family 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_aliased_projected_root_spawn_families.ql 与 fixtures/codegen/pass/ffi_export_async_aliased_projected_root_spawn_families.ql，在同一对 fixture 里显式覆盖 source-root reinit 之后经 nested struct aggregate、fixed-array aggregate、nested fixed-array aggregate，以及 helper-forwarded nested fixed-array aggregate 重包装后再 spawn -> await running 的路径，说明当前 library async 子集已能稳定承载 alias-root aggregate submit，而不再只停留在 async program public contract
ql-cli/tests/codegen.rs 现已把 guard-refined dynamic path family 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_guard_refined_dynamic_path_families.ql 与 fixtures/codegen/pass/ffi_export_async_guard_refined_dynamic_path_families.ql，在同一对 fixture 里显式覆盖 direct dynamic、projected dynamic、aliased projected-root、const-backed alias-root，以及 static-alias-backed alias-root 的 equality-guard refined reinit 路径；此前零散的 async_library_guard_refined_dynamic_task_handle_reinit.ql 已被 family 吸收删除，说明当前 library async 子集已能稳定承载整片 guard-refined dynamic path，而不再只依赖单点 staticlib success case
ql-cli/tests/codegen.rs 现已把 projected reinit family 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_projected_reinit_families.ql 与 fixtures/codegen/pass/ffi_export_async_projected_reinit_families.ql，在同一对 fixture 里显式覆盖 fixed-array literal projected reinit、conditional literal reinit、stable projected dynamic reinit、conditional projected dynamic reinit，以及 projected-root dynamic reinit；此前零散的 async_library_projected_array_reinit.ql、async_library_projected_array_conditional_reinit.ql、async_library_projected_dynamic_array_reinit.ql、async_library_projected_dynamic_array_conditional_reinit.ql 与 async_library_projected_root_dynamic_task_handle_reinit.ql 已被 family 吸收删除，说明当前 library async 子集已能稳定承载整片 projected reinit path，而不再只依赖 staticlib only success case
ql-cli/tests/codegen.rs 现已把 projected task-handle consume / submit 的 library-mode public contract 一次锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_task_handle_consume_families.ql 与 fixtures/codegen/pass/ffi_export_async_task_handle_consume_families.ql，在同一对 fixture 里显式覆盖 direct/alias 的 call-root、nested、awaited 与 inline aggregate 上的 projected task-handle await / spawn，说明当前 library async 子集已能直接消费 call-root family 的 task-handle projection，而不再只依赖 local projection
ql-cli/tests/codegen.rs 现已把 unparenthesized inline aggregate projected fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_inline_without_parens_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_inline_without_parens_for_await.ql，在同一对 fixture 里显式覆盖 direct unparenthesized inline projected scalar/task fixed-shape root，以及 alias-backed inline helper variant，说明当前 library async 子集已能直接消费无需额外外层括号的 inline aggregate root
ql-cli/tests/codegen.rs 现已把 parenthesized inline aggregate projected fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_inline_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_inline_for_await.ql，在同一对 fixture 里显式覆盖 direct inline projected scalar/task fixed-shape root，以及 alias-backed inline helper variant，说明当前 library async 子集已能直接消费 parenthesized inline aggregate root
ql-cli/tests/codegen.rs 现已把 same-file import-alias awaited-aggregate fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_import_alias_awaited_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_import_alias_awaited_for_await.ql，显式覆盖 import-aliased awaited projected scalar/task fixed-shape root，说明当前 library async 子集已能直接消费由 same-file import alias 包裹的 async helper aggregate root
ql-cli/tests/codegen.rs 现已把 same-file import-alias fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_import_alias_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_import_alias_for_await.ql，在同一对 fixture 里显式覆盖 import-aliased direct call-root 与 import-aliased nested call-root 的 scalar/task fixed-shape iterable root，说明当前 library async 子集已能直接消费 same-file import alias 包裹的 call-root family
ql-cli/tests/codegen.rs 现已把 nested call-root projected fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_nested_call_root_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_nested_call_root_for_await.ql，显式覆盖 nested call-root scalar array/tuple 与 deeper projected task-array root，说明当前 library async 子集已能直接消费嵌套 call-root aggregate projection
ql-cli/tests/codegen.rs 现已把 awaited-aggregate projected fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_awaited_projected_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_awaited_projected_for_await.ql，显式覆盖 awaited projected scalar array/tuple 与 awaited projected task tuple/array，说明当前 library async 子集已能直接消费受支持 async helper 返回的 aggregate root
ql-cli/tests/codegen.rs 现已把 direct call-root fixed-shape for await 的 library-mode public contract 锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_call_root_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_call_root_for_await.ql，显式覆盖 direct call-root scalar array/tuple 与 direct call-root task array/tuple，说明当前 library async 子集已从 local/direct root 扩展到 direct call-root iterable expression
ql-cli/tests/codegen.rs 现已把 projected fixed-shape for await 的 library-mode public contract 也锁进 staticlib / dylib：新增 fixtures/codegen/pass/async_library_projected_for_await.ql 与 fixtures/codegen/pass/ffi_export_async_projected_for_await.ql，显式覆盖 projected scalar array/tuple root 与 projected task array/tuple root，说明当前 library async 子集已从 direct root 扩展到只读 projected root
ql-resolve / ql-typeck 已开放首个显式 task-handle 类型面：Task[T] 现在作为保留类型根被接受，不再触发 unresolved-type 诊断，并映射到内部 task-handle 语义；direct async call、spawned task、局部绑定 handle 与 sync helper 返回值现在都复用同一条句柄值模型
ql-typeck 已移除 direct async call 的“必须立刻 await / spawn”限制：let task = worker(); await task、helper 参数传递、return worker() 到 Task[T] wrapper 等路径现在都可保守通过；当 direct async call 最终流入非 Task[T] 上下文时，会自然退化成普通类型不匹配，而不再依赖单独的特判诊断
ql-typeck 已把 spawn 消费模型对齐到 task-handle 语义：spawn task 与 spawn schedule()（其中 schedule() -> Task[T]）现在都可保守通过；非 task operand 会给出稳定诊断，而不再把 spawn 限死在“直接 async call”形态
ql-borrowck 已把 direct-local task handle 的 await / spawn、静态可判定的 helper Task[T] 参数传递与 direct-local return task 接进当前 ownership facts：这些路径现在会显式 consume 任务句柄，本地句柄在消费后复用会得到稳定的 use-after-move / maybe-moved 诊断，而重赋值仍可恢复 local 可用性；对 tuple index / fixed-array literal index / struct-field 的只读 projected task-handle operand，borrowck 现在也会把 consume 精确记到 projection path，而不是直接退化成 base local，因此 await pair[0]; await pair[1]、await tasks[0]; await tasks[1]、条件性消费后继续使用 sibling projection、以及读取 sibling 非 task 字段这类路径都已有回归覆盖；dynamic fixed-array index task-handle consume 现也已进入两层保守 path-sensitive 子集：generic dynamic path 只保证 sibling-safe consume，而 same immutable stable index path（例如 index、slot.value）现也会被识别为同一路径，因此 await tasks[index]; await tasks[index] 与 await tasks[slot.value]; await tasks[slot.value] 都会稳定给出 definite use-after-move，await tasks[index]; tasks[index] = worker(); await tasks[index] 与 await tasks[slot.value]; tasks[slot.value] = worker(); await tasks[slot.value] 也可恢复通过；当这类 stable dynamic source path 又被 equality guard（例如 if index == 0、if slot.value == 0）收窄到具体元素时，borrowck 现也会在 dominated branch 内回收到同一条 literal/projection path，因此 await tasks[index]; tasks[0] = worker(); await tasks[0] 不再停留在 generic dynamic maybe-overlap；同一轮里，same-file const item 也已补进这条精度边界，因此 await tasks[INDEX]; await tasks[0] 与 await tasks[SLOT.value]; tasks[0] = worker(); await tasks[SLOT.value] 不再退化回 generic dynamic maybe-overlap
ql-codegen-llvm / ql-driver / ql-cli 已补充 task-handle helper 回归：fn schedule() -> Task[Int] { return worker() } 加 await schedule() 的 staticlib 路径已被单测、driver 回归和黑盒快照锁住
ql-codegen-llvm / ql-driver / ql-cli 已补充 helper-argument task-handle 回归：let task = worker(); let forwarded = forward(task); await forwarded 与 let running = spawn forward(task); await running 这两条组合路径已被单测、driver staticlib 回归和 CLI 黑盒 fixture 锁住
ql-driver / ql-cli 已补上 async staticlib mixed-surface 回归：带内部 async helper 的库现在也锁住了 extern "c" export header sidecar 路径，确保公开 C header surface 不会被 async implementation details 污染
当前 runtime crate 仍刻意不承诺 polling、cancellation、scheduler hints 或 Rust Future 绑定，只固定最小执行器接口
当前共享 hook ABI 已冻结第一版 LLVM-facing contract string，但真实内存布局、结果传递协议和更细粒度调用约定仍未冻结
当前 backend/driver 虽已具备 declaration + async body wrapper/frame scaffold，并已打通 scalar/task-handle/递归可加载 aggregate frame/result lowering（含递归 nested aggregate-carried task-handle payload）、spawn task-handle lowering、tuple/struct-field/fixed-array projection lowering、非 Task[...] 元素 dynamic array assignment lowering、Task[...] 动态数组的 generic maybe-overlap + sibling-safe consume + same immutable stable index path precise consume/reinit 子集、same-file const item 到 literal/projection path 的最小 lowering、expected-context empty-array lowering、zero-sized async parameter/result 稳定性、fixed-array for await lowering，以及 staticlib / 最小 async dylib 子集开放，但更广义的 async iteration 协议、任务结果协议、frame 生命周期管理、更广义的布局协议、arbitrary dynamic task-handle overlap reasoning 与无期望类型的裸 [] 仍未开放
当前 async-iteration 已不再只是纯失败合同：library-mode async body 内的 fixed array for await 已走通最小 lowering；但共享 qlrt_async_iter_next hook 仍主要承担 capability/ABI 预留语义，还不代表通用 async iterator runtime 协议已经冻结
当前 Task[T] 虽已进入显式类型面，但仍是保守的句柄抽象：还没有 cancellation、polling、scheduler hint、auto-drop 语义或更一般的 async effect/type inference 设计
当前 borrowck 已对 direct-local task handle、tuple/struct-field projected task-handle 的 consume/write-reinit，以及 fixed-array literal index projected task-handle的只读 consume/write-reinit 建立最小合同；await / spawn、静态可判定的 helper Task[T] 参数传递、direct-local return task、以及 sibling projection 的控制流分支都已接入，且 tuple/struct-field 与 fixed-array literal index 投影重赋值现在都会按 path 恢复对应 task-handle 的可用性；dynamic fixed-array index task-handle 现也已打开三层子集：generic dynamic consume 会记录 dynamic-array path，不再直接污染 sibling projection；same immutable stable index path consume 会落到精确的 stable-dynamic path，因此同一路径二次读取会报 definite move；same immutable stable index path 写入也可精确恢复同一路径，而 same-file const item 若能保守折回同一 literal/projection path，也会继承同样的 definite move / precise reinit 结果；generic dynamic overlap/reinit 仍只会降级为 maybe-moved；更广义的 dynamic index lifecycle 与 drop/submission 协议仍待后续切片

下一步（P7.3 / P7.4 方向）

P7.2 两个主线任务与 P7.4 的首个 program-entry 切片均已完成（2026-03-29/30）。

P7.4 Task 1（已完成）：开放 async fn main 的 executable 程序入口

crates/ql-codegen-llvm/src/lib.rs：移除对 async fn main 的统一拒绝；在 program-mode host @main wrapper 中补齐 task_create -> executor_spawn -> task_await -> result_load -> task_result_release -> trunc/ret 生命周期 lowering，并为 void-return 路径保留 ret i32 0
crates/ql-driver/src/build.rs：允许 BuildEmit::Executable 通过 async runtime capability gate；新增 driver 单测 build_file_writes_async_main_executable_with_mock_toolchain，并继续锁定当前 program-mode 最小 runtime support 下的可执行构建路径
crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main.ql：补齐 CLI 黑盒回归，锁定 async program build 端到端成功路径
当前边界仍保持保守：llvm-ir / object 现已开放当前 async fn main program subset，其中 object 复用同一套 program-mode lowering，而 BuildEmit::Executable 继续共享最小 program-mode runtime definitions / stubs 以进入可链接、可运行路径。更广义的 program bootstrap、async dylib surface 与 task result transport 仍未开放

P7.4 Task 2（已完成）：锁定 async fn main + fixed-array for await 的 executable 闭环

crates/ql-codegen-llvm/src/lib.rs：新增 program-mode 单测 emits_async_main_entry_lifecycle_with_fixed_array_for_await_in_program_mode，锁定 async main host entry lifecycle 与 fixed-array for await lowering 在同一模块内共存
crates/ql-driver/src/build.rs：新增 executable 成功回归 build_file_writes_executable_with_async_main_fixed_array_for_await
crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_for_await_array.ql：补齐 CLI 黑盒 pass fixture，锁定 ql build --emit exe 的组合成功路径
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/*.ql / ramdon_tests/async_program_surface_examples/*.ql：新增真实 toolchain 的 build-and-run smoke harness；当前既锁住 39 个 sync executable 样例的实际退出码，也锁住 173 个 async executable 样例的实际退出码（完整列表分别以 ramdon_tests/executable_examples/README.md 与 ramdon_tests/async_program_surface_examples/README.md 为准），避免 executable surface 只剩“可构建”而没有“可运行”回归
crates/ql-codegen-llvm/src/lib.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/05_sync_named_call_arguments.ql：本轮把 backend 里此前直接拒绝的 named call arguments 打通到真实构建路径。新回归单独锁住 collect(right: 20, values: [], left: 22) 这类按参数声明顺序重排的 direct call，同时验证 named argument lowering 会继续复用 [] 的 expected-type back-propagation，而不是在 LLVM lowering 阶段退回 unsupported；真实 toolchain 下该样例现已锁定退出码 47
crates/ql-codegen-llvm/src/lib.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/06_sync_import_alias_named_call_arguments.ql：本轮继续把 direct call canonicalization 推进到 same-file use ... as ... function alias。新回归单独锁住 use collect as run; run(right: 20, values: [], left: 22) 这类 alias-root named call，会在 backend 内回收到原始 local function callee 并按声明顺序重排参数，而不再停在 “only supports direct resolved function calls”；真实 toolchain 下该样例现已锁定退出码 49
crates/ql-codegen-llvm/src/lib.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/07_sync_for_fixed_array.ql、08_sync_for_tuple.ql、09_sync_for_projected_fixed_shape.ql、10_sync_for_const_static_fixed_shape.ql：本轮把 sync fixed-shape for public surface 正式推进到真实 executable，并顺手补上之前缺失的 same-file const / static fixed-shape root lowering。backend 现在不再把 for value in VALUES / for value in INPUT 这类 same-file const/static root 或其 same-file import alias 退回 “does not support `for` lowering yet”，而是会像 local/projected fixed-shape roots 一样在函数入口 materialize 一次 iterable slot 再复用现有 array/tuple lowering。新样例分别锁住 direct fixed-array root、direct homogeneous tuple root、projected tuple/array root，以及 same-file const tuple alias + same-file static array root 的 build-and-run 路径，真实 toolchain 下都稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/11_sync_match_scrutinee_self_guard.ql：本轮继续补齐最小 literal match lowering 里一条此前错误保守的 bool guard 路径。backend 现在会在 bool arm pattern 已经约束 scrutinee 的前提下，把“guard 就是 scrutinee 自身 / 一层 unary ! 的 scrutinee”直接折叠成 always/skip，因此 match flag { true if flag => ...; false => ... } 这类最小 ordered 子集不再因为“缺少 fallback”被误拒；新样例已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/12_sync_match_scrutinee_bool_comparison_guard.ql：本轮继续把上一条 bool self-guard folding 往前推了一小步。backend 现在除了识别 flag / !flag 之外，也会把“当前 Bool scrutinee 与可折叠 Bool literal/const/static/alias 的 == / != 比较”识别成同一条 scrutinee relation，再折成 always/skip，因此 match flag { true if flag == true => ...; false => ... } 与 true if flag == ON 这类此前仍被保守留在 dynamic-guard 路径上的最小 ordered 子集，现在也能直接走非动态 bool match lowering；新样例已锁进真实 --emit exe 合同
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/13_sync_match_partial_dynamic_guard.ql：本轮继续把 bool match dynamic guard 的后端保守限制收回一段。BoolGuarded lowering 本身一直都能在 guard miss 时自然回落到 else_target，所以 backend 现在不再额外要求 later arm 提供 guaranteed true / false coverage；因此 match flag { true if enabled => ...; false => ... } 这类此前只因“缺少 later true fallback arm”而被拒的最小 ordered 子集，现在也能直接进入 lowering。新的 sync executable example 已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/14_sync_match_partial_integer_dynamic_guard.ql：本轮沿同一条线继续把 integer match dynamic guard 的后端保守限制收回一段。IntegerGuarded lowering 本身也一直都能在 guard miss 时自然回落到 else_target，所以 backend 现在不再额外要求 later unguarded catch-all fallback；因此 match value { 1 if enabled => ...; 2 => ... } 这类此前只因“缺少 later catch-all arm”而被拒的最小 ordered 子集，现在也能直接进入 lowering。新的 sync executable example 已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/15_sync_match_guard_binding_projection_roots.ql：本轮继续把 match guard 的当前 arm binding surface 往前推进一段。backend 现在不再只接受 current 作为 direct scalar operand 或 dynamic fixed-array index operand，而是也接受它作为只读 struct-field / tuple-index / fixed-array-index projection root，因此 match state { current if current.slot.ready => ... }、match pair { current if current[1] == 2 => ... } 与 match values { current if current[0] == 1 => ... } 这类此前会被保守拒绝的最小 guard projection 路径，现在也能直接进入 lowering。新的 sync executable example 已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/16_sync_match_binding_catch_all_aggregate_scrutinees.ql：本轮沿同一条非标量 match 子集继续往前推了一小步。backend 现在不再把非 Bool / Int current-loadable scrutinee 上的单名 binding catch-all arm 一律留在 unsupported 路径，而是允许它像同一子集里的 _ catch-all 一样直接回落到 arm target，因此 match state { current => current.slot.value }、match pair { current => current[0] + current[1] } 与 match values { current => current[0] + current[2] } 这类此前只因“binding catch-all fallback 仍被保守拒绝”而构建失败的最小 ordered 子集，现在也能直接进入 lowering。新的 sync executable example 已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/17_sync_match_guard_runtime_index_item_roots.ql：本轮继续沿同一条 match guard projection 路径收回一段此前过保守的 item-root 限制。backend 现在不再把 same-file const / static aggregate root 及其 same-file import alias 上的运行时 fixed-array index guard 一律留在 unsupported 路径，而是会像 local / parameter / self root 那样先 materialize 当前 item value 再复用既有只读 guard projection lowering，因此 match 0 { 0 if VALUES[index + 1] == 3 => ... }、match 0 { 0 if INPUT[state.offset] == 4 => ... } 与 match 0 { 0 if LIMITS[index + state.offset + 1] == 6 => ... } 这类此前会被 backend 误拒的最小 item-root dynamic-index guard 路径，现在也能直接进入 lowering。新的 sync executable example 已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/18_sync_match_guard_direct_calls.ql：本轮继续沿同一条 match guard scalar 路径推进到 direct call。backend 现在不再把 direct resolved sync scalar guard-call 一律留在 unsupported 路径，而是会把它们纳入当前 guard 标量子集，并在 program-mode reachability 里补收 guard-expression callee signatures，因此 match true { true if enabled() => ... } 与 match 20 { current if offset(delta: 2, value: current) == 22 => ... } 这类此前会被 backend 误拒的最小 direct guard-call 路径，现在也能直接进入 lowering。新的 sync executable example 已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/19_sync_match_guard_call_projection_roots.ql：本轮继续沿同一条 match guard direct-call 路径再推进一段，把 direct resolved sync call 的返回值正式接成只读 projection root。backend 现在不再在 pair(current)[1]、state(current).value、values(current)[1] 这类 call-root projection guard 上走到内部 panic，而是会先 materialize direct call 结果，再复用现有 tuple / struct-field / fixed-array projection lowering，因此此前会在 render 阶段崩掉的最小 aggregate-return guard-call 路径，现在也能稳定进入 lowering。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/20_sync_match_guard_aggregate_call_args.ql：本轮继续沿同一条 match guard direct-call 路径收回另一段保守限制，把实参从“只限标量”推进到“当前可加载的聚合值表达式”。backend 现在不再把 enabled(current)、matches(pair(current), 22)、contains(values(current), 4) 这类 aggregate-arg guard-call 一律留在 unsupported 路径，而是允许 local/current-binding/item-root/projection-root/call-root 上的 read-only loadable tuple / non-generic struct / fixed-array 先被取值，再按普通 by-value call argument 进入 lowering；此前那条“非标量 guard-call 参数”负例因此被转正成真实 build-and-run 回归，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/21_sync_match_guard_inline_aggregate_call_args.ql：本轮继续沿同一条 match guard direct-call 路径再收回一段保守限制，把 inline tuple / fixed-array / non-generic struct literal 也接进 guard-call 实参。backend 现在不再把 enabled(State { ready: true })、matches((0, current), 22)、contains([current, current + 1, current + 2], 4) 这类 inline-aggregate-arg guard-call 一律留在 unsupported 路径，而是会先按当前 guard 子集递归构造 loadable aggregate value，再按普通 by-value call argument 进入 lowering。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/22_sync_match_guard_inline_projection_roots.ql：本轮继续沿同一条 match guard projection 路径再收回一段保守限制，把 inline tuple / fixed-array / non-generic struct literal 本身也接成只读 projection root。backend 现在不再在 (0, current)[1]、State { value: current }.value、[current, current + 1, current + 2][1] 这类 inline-literal projection guard 上走到内部 panic，而是会先 materialize inline aggregate literal，再复用现有 tuple / struct-field / fixed-array projection lowering。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/23_sync_match_guard_item_backed_inline_combos.ql：本轮没有继续扩新 lowering 分支，而是把上一轮已经自然可用、但还没显式进入 public surface 的 item-backed inline 组合路径正式收口到 codegen / driver / real executable matrix。新的定向回归确认 import-alias direct guard-call 的 named aggregate args、item-backed inline tuple literal elements (INPUT[0], current)[1]，以及 item-backed inline array root 上的 runtime dynamic index [INPUT[0], current + 1, INPUT[2]][current - 2] 现在都会稳定复用既有 guard-call / inline aggregate / projection lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/24_sync_match_guard_call_backed_combos.ql：本轮继续沿同一条 match guard direct-call / inline aggregate / projection 路径，把 direct sync scalar call 继续组合进更深一层的用户可写表达式形态，并正式收口到 public regression matrix。新的定向回归确认 call-backed inline struct field State { ready: ready(true) }、call-backed inline tuple element (seed(0), current)，以及 import-alias call-root 上的 runtime dynamic index items(current)[slot(current)] 现在都会稳定复用既有 guard-call / inline aggregate / projection lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/25_sync_match_guard_call_root_nested_runtime_projection.ql：本轮继续沿同一条 match guard call-root projection 路径，把 direct sync call 的 nested aggregate 返回值进一步推进到 runtime dynamic index，并把该投影结果继续参与 direct scalar comparison 与 direct guard-call scalar arguments 的组合一并收口到 public regression matrix。新的定向回归确认 pack(current).values[offset(current)] == 4、ready(pack(current).values[offset(current)]) 与 check(expected: 4, value: pack(current).values[offset(current)]) 现在都会稳定复用既有 call-root materialize、nested projection 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/26_sync_match_guard_nested_call_root_inline_combos.ql：本轮继续沿同一条 match guard nested call-root projection 路径，再把该投影结果推进到 inline aggregate element、inline projection root 与 aggregate guard-call argument 的组合层。新的定向回归确认 [pack(current)[slot(current)], current + 1, 6][0] == 4、contains([pack(3)[slot(3)], current, 9], 4) 与 check(expected: 4, value: pair(left: pack(current)[slot(current)], right: 8)[0]) 现在都会稳定复用既有 call-root materialize、runtime dynamic index、inline aggregate 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/27_sync_match_guard_item_backed_nested_call_root_combos.ql：本轮继续沿同一条 match guard nested call-root projection 路径，把 same-file item-backed scalar root 继续混进 guard-call 条件、inline aggregate element 与 aggregate guard-call argument 的组合层，并正式收口到 public regression matrix。新的定向回归确认 enabled(extra: INPUT[0] == bundle(3)[offset(3)], state: state(bundle(3)[offset(3)] == 4))、[bundle(current)[offset(current)], INPUT[1], INPUT[2]][0] == INPUT[0] 与 check(expected: INPUT[0], value: [bundle(current)[offset(current)], 8, 9][0]) 现在都会稳定复用既有 item-root materialize、nested call-root runtime projection、inline aggregate 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/28_sync_match_guard_call_backed_nested_call_root_combos.ql：本轮继续沿同一条 match guard nested call-root projection 路径，把 direct scalar calls 继续混进 guard-call 条件、inline aggregate element 与 aggregate guard-call argument 的组合层，并正式收口到 public regression matrix。新的定向回归确认 enabled(extra: flag(pack(3)[slot(3)] == 4), state: state(flag(pack(3)[slot(3)] == 4)))、[pack(current)[slot(current)], seed(8), seed(9)][0] == seed(4) 与 check(expected: seed(4), value: [pack(current)[slot(current)], seed(8), 9][0]) 现在都会稳定复用既有 call-root materialize、direct scalar call、inline aggregate 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/29_sync_match_guard_alias_backed_nested_call_root_combos.ql：本轮继续沿同一条 match guard nested call-root projection 路径，把 same-file use ... as ... alias call canonicalization 继续混进 guard-call 条件、inline aggregate element 与 aggregate guard-call argument 的组合层，并正式收口到 public regression matrix。新的定向回归确认 allow(extra: flag(pack(3)[slot(3)] == literal(4)), state: make(flag(pack(3)[slot(3)] == literal(4))))、[pack(current)[slot(current)], literal(8), literal(9)][0] == literal(4) 与 check(expected: literal(4), value: [pack(current)[slot(current)], literal(8), 9][0]) 现在都会稳定复用既有 import-alias direct call canonicalization、nested call-root runtime projection、inline aggregate 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/30_sync_match_guard_binding_backed_nested_call_root_combos.ql：本轮继续沿同一条 match guard nested call-root projection 路径，把非标量 current-binding guard 继续混进 inline aggregate element 与 aggregate guard-call argument 的组合层，并正式收口到 public regression matrix。新的定向回归确认 enabled(extra: bundle(current.value)[offset(current.value)] == 4, state: current)、[bundle(current.value)[offset(current.value)], current.value + 5, 9][0] == 4 与 matches(expected: 4, value: [bundle(current.value)[offset(current.value)], current.value, 9][0]) 现在都会稳定复用既有 non-scalar current-binding guard、nested call-root runtime projection、inline aggregate 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/31_sync_match_guard_projection_backed_nested_call_root_combos.ql：本轮继续沿同一条 match guard nested call-root projection 路径，把 read-only projection-root guard 继续混进 inline aggregate element 与 aggregate guard-call argument 的组合层，并正式收口到 public regression matrix。新的定向回归确认 enabled(extra: bundle(config.slot.value)[offset(config.slot.value)] == 4, state: state(bundle(config.slot.value)[offset(config.slot.value)] == 4))、[bundle(config.slot.value)[offset(config.slot.value)], current + 5, 9][0] == 4 与 matches(expected: 4, value: [bundle(config.slot.value)[offset(config.slot.value)], current, 9][0]) 现在都会稳定复用既有 read-only projection-root guard、nested call-root runtime projection、inline aggregate 与 scalar guard-call lowering，而不再只停留在 probe 级别的“看起来能过”。新的 sync executable example 已锁进真实 build-and-run 合同，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/137_async_main_const_tuple_for_await.ql、138_async_main_static_array_for_await.ql、139_async_main_import_alias_projected_const_tuple_for_await.ql、140_async_main_import_alias_projected_static_array_for_await.ql：本轮继续把上一轮刚打通的 same-file const / static fixed-shape root lowering 推进到 async executable public surface。新增四条 committed executable examples 分别锁住 direct const tuple root、direct static array root、same-file import-alias projected const tuple root，以及 same-file import-alias projected static array root 的 scalar for await build-and-run 路径；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42 / 42 / 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/141_async_main_import_alias_const_tuple_for_await.ql、142_async_main_import_alias_static_array_for_await.ql：本轮继续沿着同一条 async fixed-shape public slice 收口 same-file use ... as ... 直接别名根路径。新增两条 committed executable examples 分别锁住 import-aliased direct const tuple root 与 import-aliased direct static array root 的 scalar for await build-and-run 路径；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/143_async_main_call_root_projected_task_handle_consumes.ql：本轮没有继续扩新 lowering 分支，而是把已自然可用但还没进入 committed contract 的 direct call-root / projected call-root task-handle consume 正式收口到 executable public surface。新样例显式锁住 await tuple_tasks(10)[0]、spawn pair_tasks(11).left、await bundle_tasks(20).tasks[0] 与 spawn bundle_tasks(0).tasks[1] 这几条 call-root / projected call-root consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/32_sync_for_call_root_fixed_shapes.ql：本轮没有扩新 backend 分支，而是把已 probe 成功但还没进入 committed contract 的 sync fixed-shape iterable call-root slice 正式收口到 executable public surface。新样例显式锁住 for value in array_values(10)、for value in tuple_values(7) 与 for value in make_payload(3).values 这几条 direct call-root / projected call-root fixed-shape for 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/144_async_main_call_root_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 direct call-root / projected call-root for await。新样例显式锁住 for await value in array_values(8)、for await value in tuple_values(4)、for await value in task_values(2) 与 for await value in make_pending(5).tasks 这几条 scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/33_sync_import_alias_call_root_fixed_shapes.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file function import alias call-root for。新样例显式锁住 for value in values(10)、for value in pairs(7) 与 for value in payload(3).values 这几条 import-aliased direct/projected call-root fixed-shape for 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/145_async_main_import_alias_call_root_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file function import alias call-root for await。新样例显式锁住 for await value in values(8)、for await value in pairs(4)、for await value in tasks(2) 与 for await value in pending(5).tasks 这几条 import-aliased scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/34_sync_nested_call_root_fixed_shapes.ql：本轮继续沿 fixed-shape iterable public slice 收口 nested call-root projected for。新样例显式锁住 for value in array_env(10).payload.values、for value in tuple_env(7).payload.values 与 for value in deep_env(3).outer.payload.values 这几条 nested projected fixed-array / homogeneous tuple iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/146_async_main_nested_call_root_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 nested call-root projected for await。新样例显式锁住 for await value in array_env(8).payload.values、for await value in tuple_env(4).payload.values、for await value in task_tuple_env(2).payload.values 与 for await value in deep_task_env(5).outer.payload.tasks 这几条 nested projected scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与更深一层 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/35_sync_import_alias_nested_call_root_fixed_shapes.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file import-alias nested call-root projected for。新样例显式锁住 for value in arrays(10).payload.values、for value in tuples(7).payload.values 与 for value in deep(3).outer.payload.values 这几条 import-aliased nested projected fixed-array / homogeneous tuple iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/147_async_main_import_alias_nested_call_root_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file import-alias nested call-root projected for await。新样例显式锁住 for await value in arrays(8).payload.values、for await value in tuples(4).payload.values、for await value in task_tuples(2).payload.values 与 for await value in deep(5).outer.payload.tasks 这几条 import-aliased nested projected scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与更深一层 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/36_sync_inline_projected_fixed_shapes.ql：本轮没有扩新 backend 分支，而是把带括号的 inline aggregate projected fixed-shape for 正式收口到 executable public surface。新样例显式锁住 for value in (ArrayPayload { values: [10, 11] }).values、for value in (TuplePayload { values: (7, 8) }).values 与 for value in (DeepPayload { inner: ArrayPayload { values: [3, 3] } }).inner.values 这几条 inline projected fixed-array / homogeneous tuple iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/37_sync_import_alias_inline_projected_fixed_shapes.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file import-alias 带括号 inline aggregate projected for。新样例显式锁住 for value in (ArrayPayload { values: [make_value(10), make_value(11)] }).values、for value in (TuplePayload { values: (make_value(7), make_value(8)) }).values 与 for value in (DeepPayload { inner: ArrayPayload { values: [make_value(3), make_value(3)] } }).inner.values 这几条 alias-backed inline projected fixed-array / homogeneous tuple iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-parser/src/parser/expr.rs + crates/ql-parser/src/parser/stmt.rs + crates/ql-parser/tests/parser_fixtures.rs：本轮把 for / for await iterable 头从“完全禁止 struct literal”推进到“允许无括号 inline aggregate，但只在后面立刻跟投影时收口成 struct literal”，避免把普通 for item in ready {} 这种循环头重新吃坏。新增 parser 回归明确锁住 for value in Payload { values: [1, 2] }.values {} 与 for await value in Payload { values: [3, 4] }.values {} 这两种不带括号的 inline aggregate projection 现在都会稳定解析成 StructLiteral -> Member iterable，而不再因为循环头的 struct-literal bias 被误判成 expected ';' or end of block / expected expression
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/148_async_main_import_alias_call_root_projected_task_handle_consumes.ql：本轮没有扩新 backend 分支，而是把已自然可用但还没进入 committed contract 的 same-file import-alias call-root projected task-handle consume 正式收口到 executable public surface。新样例显式锁住 await tuples(10)[0]、spawn pairs(11).left、await bundles(20).tasks[0] 与 spawn bundles(0).tasks[1] 这几条 import-aliased call-root tuple/struct-field/fixed-array projection consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/149_async_main_import_alias_nested_call_root_projected_task_handle_consumes.ql：本轮继续沿 projected task-handle consume public slice 收口 same-file import-alias nested call-root consume。新样例显式锁住 await tuples(10).payload.values[0]、spawn pairs(11).payload.left、await deep(20).outer.payload.tasks[0] 与 spawn deep(0).outer.payload.tasks[1] 这几条 import-aliased nested tuple/struct-field/deeper-task-array projection consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/150_async_main_import_alias_awaited_aggregate_projected_task_handle_consumes.ql：本轮继续沿 projected task-handle consume public slice 收口 same-file import-alias awaited-aggregate consume。新样例显式锁住 await (await tuples(10)).payload.values[0]、spawn (await pairs(11)).payload.left、await (await deep(20)).outer.payload.tasks[0] 与 spawn (await deep(0)).outer.payload.tasks[1] 这几条 import-aliased awaited-aggregate tuple/struct-field/deeper-task-array projection consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/151_async_main_awaited_aggregate_projected_task_handle_consumes.ql：本轮继续沿 projected task-handle consume public slice 收口 direct awaited-aggregate consume。新样例显式锁住 await (await make_tuple_env(10)).payload.values[0]、spawn (await make_pair_env(11)).payload.left、await (await make_deep_env(20)).outer.payload.tasks[0] 与 spawn (await make_deep_env(0)).outer.payload.tasks[1] 这几条 direct awaited-aggregate tuple/struct-field/deeper-task-array projection consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/152_async_main_inline_projected_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口带括号的 inline aggregate projected for await。新样例显式锁住 for await value in (ScalarArrayPayload { values: [8, 9] }).values、for await value in (ScalarTuplePayload { values: (4, 5) }).values、for await value in (TaskTuplePayload { values: (worker(2), worker(3)) }).values 与 for await value in (DeepPending { outer: PendingEnvelope { payload: Pending { tasks: [worker(5), worker(6)] } } }).outer.payload.tasks 这几条 inline projected scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与更深一层 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/153_async_main_inline_projected_task_handle_consumes.ql：本轮继续沿 projected task-handle consume public slice 收口带括号的 inline aggregate projected consume。新样例显式锁住 await (TuplePayload { values: (worker(10), worker(11)) }).values[0]、spawn (Pair { left: worker(11), right: worker(12) }).left、await (DeepEnvelope { outer: BundleEnvelope { payload: Bundle { tasks: [worker(20), worker(21)] } } }).outer.payload.tasks[0] 与 spawn (DeepEnvelope { outer: BundleEnvelope { payload: Bundle { tasks: [worker(0), worker(1)] } } }).outer.payload.tasks[1] 这几条 inline projected tuple/struct-field/deeper-task-array consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/154_async_main_import_alias_inline_projected_task_handle_consumes.ql：本轮继续沿 projected task-handle consume public slice 收口 same-file import-alias inline aggregate projected consume。新样例显式锁住 await (TuplePayload { values: (run(10), run(11)) }).values[0]、spawn (Pair { left: run(11), right: run(12) }).left、await (DeepEnvelope { outer: BundleEnvelope { payload: Bundle { tasks: [run(20), run(21)] } } }).outer.payload.tasks[0] 与 spawn (DeepEnvelope { outer: BundleEnvelope { payload: Bundle { tasks: [run(0), run(1)] } } }).outer.payload.tasks[1] 这几条 alias-backed inline projected tuple/struct-field/deeper-task-array consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/155_async_main_import_alias_inline_projected_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file import-alias inline aggregate projected for await。新样例显式锁住 for await value in (ScalarArrayPayload { values: [make_value(8), make_value(9)] }).values、for await value in (ScalarTuplePayload { values: (make_value(4), make_value(5)) }).values、for await value in (TaskTuplePayload { values: (run(2), run(3)) }).values 与 for await value in (DeepPending { outer: PendingEnvelope { payload: Pending { tasks: [run(5), run(6)] } } }).outer.payload.tasks 这几条 alias-backed inline projected scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/156_async_main_awaited_aggregate_projected_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 awaited-aggregate projected for await。新样例显式锁住 for await value in (await array_env(8)).payload.values、for await value in (await tuple_env(4)).payload.values、for await value in (await task_tuple_env(2)).payload.values 与 for await value in (await deep_task_env(5)).outer.payload.tasks 这几条 awaited projected scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/157_async_main_import_alias_awaited_aggregate_projected_fixed_shape_for_await.ql：本轮继续沿 fixed-shape iterable public slice 收口 same-file import-alias awaited-aggregate projected for await。新样例显式锁住 for await value in (await arrays(8)).payload.values、for await value in (await tuples(4)).payload.values、for await value in (await task_tuples(2)).payload.values 与 for await value in (await deep(5)).outer.payload.tasks 这几条 alias-backed awaited projected scalar fixed-array、scalar homogeneous tuple、task-tuple auto-await 与 projected task-array iterable 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/158_async_main_nested_call_root_projected_task_handle_consumes.ql：本轮继续沿 projected task-handle consume public slice 收口 direct nested call-root consume。新样例显式锁住 await tuple_env(10).payload.values[0]、spawn pair_env(11).payload.left、await deep_env(20).outer.payload.tasks[0] 与 spawn deep_env(0).outer.payload.tasks[1] 这几条 direct nested tuple/struct-field/deeper-task-array projection consume 路径，在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/38_sync_inline_projected_fixed_shapes_without_parens.ql + ramdon_tests/async_program_surface_examples/159_async_main_inline_projected_fixed_shape_for_await_without_parens.ql：本轮继续沿 fixed-shape iterable public slice，把“不带括号的 inline aggregate projection”正式推进到 sync / async executable public surface。两条新样例分别显式锁住 for value in ArrayPayload { values: [10, 11] }.values、for value in TuplePayload { values: (7, 8) }.values、for value in DeepPayload { inner: ArrayPayload { values: [3, 3] } }.inner.values，以及 for await value in ScalarArrayPayload { values: [8, 9] }.values、for await value in ScalarTuplePayload { values: (4, 5) }.values、for await value in TaskTuplePayload { values: (worker(2), worker(3)) }.values 与 for await value in DeepPending { outer: PendingEnvelope { payload: Pending { tasks: [worker(5), worker(6)] } } }.outer.payload.tasks，确认 parser 放宽后这条无括号 form 在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-parser/src/parser/expr.rs + crates/ql-parser/tests/parser_fixtures.rs + crates/ql-cli/tests/executable_examples.rs + ramdon_tests/executable_examples/39_sync_unparenthesized_inline_projected_control_flow_heads.ql：本轮继续沿同一条 parser 语法线，把 if / while / match 头从“完全禁止 struct literal”推进到“允许无括号 inline aggregate，但只在后面立刻跟投影时收口成 struct literal”，避免把普通 if ready {} / match value {} 重新吃坏。新的 parser 回归显式锁住 if FlagState { ready: true }.ready {}、while FlagState { ready: false }.ready {} 与 match PairPayload { values: (1, 2) }.values[0] { ... } 会稳定解析成 StructLiteral -> Member/Bracket 头表达式；新的 sync executable example 则进一步确认 if FlagState { ready: true }.ready、while FlagState { ready: false }.ready 与 match PairPayload { values: (20, 22) }.values[1] 在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/160_async_main_awaited_match_guards.ql：本轮把当前已自然可用但尚未进入 committed contract 的 async executable match guard surface 正式收口。新样例显式锁住 let first = await fetch_value(...); match first { current if offset(delta: 2, value: current) == 22 => ... } 与 let second = await load_state(...); match second { current if current.slot.ready => ... } 这两条 awaited-scalar + direct-call guard、awaited-aggregate + projection guard 路径，确认它们在 async fn main 下会稳定复用既有 match lowering 与 program-mode async entry/runtime glue，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/161_async_main_awaited_match_aggregate_guard_calls.ql：本轮继续把当前已自然可用但尚未进入 committed contract 的 async executable match guard-call surface 正式收口。新样例显式锁住 match first { current if matches(expected: 22, value: current.values) => ... } 与 match second { current if matches(expected: 22, value: pair(value: current.values.left)) => ... } 这两条 awaited aggregate scrutinee + projected aggregate guard-call arg、awaited aggregate scrutinee + call-backed aggregate guard-call arg 路径，确认它们在 async fn main 下会稳定复用既有 aggregate guard-call lowering 与 program-mode async entry/runtime glue，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/162_async_main_import_alias_awaited_match_guards.ql：本轮继续把 same-file import-alias async executable match guard surface 正式收口。新样例显式锁住 let first = await load_scalar(...); match first { current if shift(delta: 2, value: current) == 22 => ... }、match second { current if check(expected: 22, value: current.values) => ... } 与 match third { current if check(expected: 22, value: make_pair(value: current.values.left)) => ... } 这三条 import-alias rooted awaited helper / guard helper 路径，确认它们在 async fn main 下会稳定复用既有 import-alias call lowering、aggregate guard-call lowering 与 program-mode async entry/runtime glue，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 62
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/163_async_main_awaited_match_nested_call_root_guards.ql：本轮继续把 async executable match 的 nested call-root guard surface 正式收口。新样例显式锁住 match first { current if pack(current).values[slot(current)] == 4 => ... }、match second { current if ready(pack(current).values[slot(current)]) => ... } 与 match third { current if check(value: pack(current).values[slot(current)], expected: 4) => ... } 这三条 awaited scalar scrutinee + nested call-root runtime projection 路径，确认它们在 async fn main 下会稳定复用既有 call-root materialize、nested runtime projection、direct predicate/guard-call lowering 与 program-mode async entry/runtime glue，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/164_async_main_awaited_match_call_backed_nested_call_root_guards.ql：本轮继续把 async executable match 的 call-backed nested call-root guard surface 正式收口。新样例显式锁住 match first { true if enabled(extra: flag(pack(3)[slot(3)] == 4), state: flag_state(flag(pack(3)[slot(3)] == 4))) => ... }、match second { current if [pack(current)[slot(current)], seed(8), seed(9)][0] == seed(4) => ... } 与 match third { current if equal(expected: seed(4), value: [pack(current)[slot(current)], seed(8), 9][0]) => ... } 这三条 awaited scrutinee + call-backed nested call-root 路径，确认它们在 async fn main 下会稳定复用既有 call-root materialize、direct scalar call、inline aggregate element、scalar guard-call lowering 与 program-mode async entry/runtime glue，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/165_async_main_awaited_match_alias_backed_nested_call_root_guards.ql：本轮继续把 async executable match 的 alias-backed nested call-root guard surface 正式收口。新样例显式锁住 match first { true if allow(extra: flag(pack(3)[slot(3)] == literal(4)), state: make(flag(pack(3)[slot(3)] == literal(4)))) => ... }、match second { current if [pack(current)[slot(current)], literal(8), literal(9)][0] == literal(4) => ... } 与 match third { current if check(expected: literal(4), value: [pack(current)[slot(current)], literal(8), 9][0]) => ... } 这三条 awaited scrutinee + alias-backed nested call-root 路径，确认它们在 async fn main 下会稳定复用既有 import-alias call canonicalization、call-root materialize、inline aggregate element、scalar guard-call lowering 与 program-mode async entry/runtime glue，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/166_async_main_awaited_match_binding_backed_nested_call_root_guards.ql + 167_async_main_awaited_match_projection_backed_nested_call_root_guards.ql：本轮继续把 async executable match 的 binding-backed / projection-backed nested call-root guard surface 一次性收口。两条新样例分别显式锁住 match first { current if enabled(extra: bundle(current.value)[offset(current.value)] == 4, state: current) => ... }、match second { current if [bundle(current.value)[offset(current.value)], current.value + 5, 9][0] == 4 => ... }、match third { current if matches(expected: 4, value: [bundle(current.value)[offset(current.value)], current.value, 9][0]) => ... }，以及 match first { true if enabled(extra: bundle(config.slot.value)[offset(config.slot.value)] == 4, state: state(bundle(config.slot.value)[offset(config.slot.value)] == 4)) => ... }、match second { current if [bundle(config.slot.value)[offset(config.slot.value)], current + 5, 9][0] == 4 => ... }、match third { current if matches(expected: 4, value: [bundle(config.slot.value)[offset(config.slot.value)], current, 9][0]) => ... }，确认 awaited aggregate current-binding 与 read-only projection-root 现在都可与 nested call-root runtime projection 继续组合进入 program-mode async match guard lowering，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/168_async_main_awaited_match_item_backed_nested_call_root_guards.ql：本轮继续把 async executable match 的 item-backed nested call-root guard surface 正式收口。新样例显式锁住 match first { true if enabled(extra: INPUT[0] == bundle(3)[offset(3)], state: state(bundle(3)[offset(3)] == 4)) => ... }、match second { current if [bundle(current)[offset(current)], INPUT[1], INPUT[2]][0] == INPUT[0] => ... } 与 match third { current if matches(expected: INPUT[0], value: [bundle(current)[offset(current)], 8, 9][0]) => ... }，确认 same-file item-backed roots 现在也可与 awaited bool/int scrutinee、nested call-root runtime projection、inline aggregate element 与 scalar guard-call lowering 继续组合进入 program-mode async match guard lowering，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/169_async_main_awaited_match_item_backed_inline_combos.ql + 170_async_main_awaited_match_call_backed_combos.ql：本轮继续把 async executable match 的 item/import-alias-backed inline guard combos 与 direct call-backed guard combos 一次性收口。两条新样例分别显式锁住 match first { true if enabled(extra: true, state: State { ready: true, value: 7 }) => ... }、match second { current if (INPUT[0], current)[1] == READY.value => ... }、match third { current if [INPUT[0], current + 1, INPUT[2]][current - 2] == 4 => ... }，以及 match first { true if enabled(extra: ready(true), state: State { ready: ready(true) }) => ... }、match second { current if matches((seed(0), current), 22) => ... }、match third { current if items(current)[slot(current)] == 4 => ... }，确认 same-file item-backed inline tuple/array root、import-aliased direct guard helper、inline struct-field call、inline tuple guard-call arg 与 direct call-root runtime projection 现在都可与 awaited bool/int scrutinee 继续组合进入 program-mode async match guard lowering，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/171_async_main_awaited_match_inline_aggregate_call_args.ql + 172_async_main_awaited_match_inline_projection_roots.ql：本轮继续把 async executable match 的 inline aggregate guard-call arg 与 inline projection-root surface 一次性收口。两条新样例分别显式锁住 match first { true if enabled(State { ready: true }) => ... }、match second { current if matches((0, current), 22) => ... }、match third { current if contains([current, current + 1, current + 2], 4) => ... }，以及 match first { current if (0, current)[1] == 22 => ... }、match second { current if State { value: current }.value == 22 => ... }、match third { current if [current, current + 1, current + 2][1] == 4 => ... }，确认 inline struct/tuple/array aggregate arg 与 inline tuple/struct/array projection root 现在都可与 awaited bool/int scrutinee 继续组合进入 program-mode async match guard lowering，并在真实本地 toolchain 下 build-and-run 成功、稳定退出 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/173_async_main_awaited_match_nested_call_root_inline_combos.ql + fixtures/codegen/pass/async_library_match_families.ql + fixtures/codegen/pass/ffi_export_async_match_families.ql：本轮继续把 async match 的 nested call-root deeper inline-combo surface 收口到 executable 与 library 两条公开合同。新的 executable 样例显式锁住 match first { current if [pack(current).values[slot(current)], current + 1, 6][0] == 4 => ... }、match second { current if contains([current, pack(current).values[slot(current)], 9], 4) => ... } 与 match third { current if matches((8, pack(current).values[slot(current)]), 4) => ... }；两条 library family fixture 则用对应的现有 array-root helper 形态 pack(current)[slot(current)] 锁住同一族路径。两边共同确认 awaited scalar scrutinee 上的 nested call-root runtime projection 现在还能继续流入 inline projection root、inline array guard-call arg 与 inline tuple guard-call arg，并在 async fn main 的真实本地 toolchain 下 build-and-run 成功、同时在 staticlib / 最小 async dylib library surface 下稳定通过构建
crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_library_for_await_tuple.ql + fixtures/codegen/pass/ffi_export_async_for_await_tuple.ql：本轮把 homogeneous tuple for await 正式补进 library build public contract。新的 pass cases 分别显式锁住 async_library_for_await_tuple_staticlib 与 ffi_export_async_for_await_tuple_dylib，确认 for await value in (1, 2, 3) 这条 tuple iterable 路径在 staticlib 与最小 async dylib surface 下都会稳定通过；同时删除了已经失真的 unsupported_async_for_await_library_build / unsupported_async_for_await_dylib_build 旧失败合同，避免测试矩阵继续错误描述当前能力边界
crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_library_task_array_for_await.ql + fixtures/codegen/pass/ffi_export_async_task_tuple_for_await.ql：本轮继续把 library build for await public contract 从 scalar fixed-shape iterable 推进到 task-backed auto-await iterable。新的 pass cases 分别显式锁住 async_library_task_array_for_await_staticlib 与 ffi_export_async_task_tuple_for_await_dylib，确认 for await value in [worker(20), worker(22)] 与 for await value in (worker(20), worker(22)) 这两条 direct task-array / direct task-tuple auto-await 路径在当前 staticlib / 最小 async dylib surface 下都会稳定通过
crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_library_task_tuple_for_await.ql + fixtures/codegen/pass/ffi_export_async_task_array_for_await.ql：本轮继续把 direct task-backed for await 的 library build public contract 补成对称矩阵。新增 pass cases 显式锁住 async_library_task_tuple_for_await_staticlib 与 ffi_export_async_task_array_for_await_dylib，确认 for await value in (worker(20), worker(22)) 与 for await value in [worker(20), worker(22)] 在当前 staticlib / 最小 async dylib surface 下同样都会稳定通过；至此，direct task-array 与 direct task-tuple auto-await for await 已在两条 library build surface 上全部进入公开合同
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/107_async_main_import_alias_named_calls.ql：本轮把 same-file function import alias direct call 正式推进到 async fn main 的真实 executable public surface。新样例单独锁住 use worker as run; use score as total; let task = run(value: 20); let first = await task; return total(right: 22, left: first) 这条 alias-root async direct call + named arguments 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/108_async_main_import_alias_direct_submit.ql：本轮继续把 same-file function import alias async call 推进到更贴近真实提交语义的 executable public surface。新样例单独锁住 await run(value: 20) 与 spawn run(value: 22) 这条 alias-root direct-submit 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/109_async_main_import_alias_aggregate_submit.ql：本轮继续把 same-file function import alias async call 推进到 aggregate-carried task-handle submit 的 executable public surface。新样例单独锁住 let pending = Pending { first: run(value: 20), second: run(value: 22) }; await pending.first; let running = spawn pending.second 这条 alias-root aggregate submit 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/110_async_main_import_alias_array_submit.ql：本轮继续把 same-file function import alias async call 推进到 fixed-array-carried task-handle submit 的 executable public surface。新样例单独锁住 let pending = [run(value: 20), run(value: 22)]; await pending[0]; let running = spawn pending[1] 这条 alias-root fixed-array submit 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/111_async_main_import_alias_tuple_submit.ql：本轮继续把 same-file function import alias async call 推进到 tuple-carried task-handle submit 的 executable public surface。新样例单独锁住 let pending = (run(value: 20), run(value: 22)); await pending[0]; let running = spawn pending[1] 这条 alias-root tuple submit 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/112_async_main_import_alias_forward_submit.ql：本轮继续把 same-file function import alias async call 推进到 helper-forwarded task-handle submit 的 executable public surface。新样例单独锁住 await forward(run(value: 20)) 与 spawn forward(run(value: 22)) 这条 alias-root helper-forwarded submit 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/113_async_main_import_alias_helper_task_submit.ql：本轮继续把 same-file function import alias async call 推进到同步 helper-returned task-handle submit 的 executable public surface。新样例单独锁住 use make_handle as run; await run(value: 20); let running = spawn run(value: 22) 这条 alias-root helper-returned-task submit 组合路径，在真实 toolchain 下锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/114_async_main_import_alias_helper_forward_submit.ql：本轮继续把 same-file function import alias async call 推进到“同步 helper 返回 Task 再经 helper-forwarded” 的 executable public surface。新样例单独锁住 await forward(run(value: 20)) 与 spawn forward(run(value: 22))，其中 run 解析到 use make_handle as run 这条 helper-returned-task 路径，在真实 toolchain 下锁定退出码 42
crates/ql-typeck/src/typing.rs + crates/ql-typeck/tests/async_typing.rs：本轮继续把 fixed-array for await 从“只拿到元素原型”推进到真实 task-array 语义：普通 iterable 仍按元素类型绑定，而 [Task[T]; N] 现在会把循环变量直接绑定成自动 await 后的 T。新增定向回归锁住两点：for await value in [make_handle(1), make_handle(2)] { total = total + value } 现在能稳定通过；而对同一个 value 再写一次 await value 会给出稳定的“await 需要 task handle operand”诊断。
crates/ql-analysis/src/runtime.rs + crates/ql-analysis/tests/queries.rs + crates/ql-codegen-llvm/src/lib.rs：本轮同步把这条 for await auto-await 语义接进 shared runtime requirement / backend lowering。analysis 现在会为 for await 额外声明 TaskAwait capability，避免 task-array loop 在没有显式 inner await 时漏掉 runtime hook 计划；backend 的 for await setup block 现在会对 [Task[T]; N] 元素直接发 qlrt_task_await + qlrt_task_result_release，并把载荷写入循环变量。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/115_async_main_import_alias_task_array_for_await.ql：same-file import alias + helper-returned task-handle 的 fixed-array for await executable public surface 已同步切到新语义。样例现在锁住 for await value in [run(value: 20), run(value: 22)] { total = total + value } 这条 alias-root task-array auto-await loop path，并在真实 toolchain 下继续锁定退出码 42
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/116_async_main_import_alias_helper_task_array_for_await.ql、117_async_main_projected_task_array_for_await.ql、118_async_main_void_task_array_for_await.ql：本轮继续把 task-array for await auto-await public surface 往最短的真实路径扩面。新增三条 committed executable examples 分别锁住 same-file import alias + helper-returned fixed-array iterable、projected struct-field fixed-array iterable，以及 Task[Void] + wildcard loop pattern 三个变体；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42 / 2。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/119_async_main_awaited_aggregate_task_array_for_await.ql、120_async_main_awaited_nested_aggregate_task_array_for_await.ql、121_async_main_import_alias_awaited_aggregate_task_array_for_await.ql：本轮继续把 task-array for await auto-await public surface 向 awaited aggregate roots 扩面。新增三条 committed executable examples 分别锁住 await make_pending(...).tasks 的展开形态、await make_env(...).bundle.tasks 的 nested aggregate 形态，以及 same-file import alias await schedule(...) 后再 for await projected task-array field 的形态；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42 / 42。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/122_async_main_inline_awaited_task_array_for_await.ql、123_async_main_awaited_tuple_projected_task_array_for_await.ql、124_async_main_awaited_array_projected_task_array_for_await.ql：本轮继续把 task-array for await auto-await public surface 向 awaited fixed-array roots 与更广的 projected roots 扩面。新增三条 committed executable examples 分别锁住 for await value in await make_tasks(...) 的 inline-awaited fixed-array root 形态、let pair = await make_pair(...); for await value in pair[0] 的 awaited tuple-projected root 形态，以及 let batches = await make_batches(...); for await value in batches[0] 的 awaited array-projected root 形态；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42 / 42。
crates/ql-typeck/src/typing.rs + crates/ql-typeck/tests/typing.rs + crates/ql-typeck/tests/async_typing.rs + crates/ql-codegen-llvm/src/lib.rs + crates/ql-driver/src/build.rs：本轮继续把 for / for await lowering 从 fixed-array 推进到 homogeneous tuple 这条不新增 runtime ABI 的 fixed-shape 子集。typeck 现在会把 (T, T, ...) 与 (Task[T], Task[T], ...) 当作稳定 iterable 绑定 loop item 类型，task tuple 在 for await 下会继续自动 await 元素；backend 会对 tuple root 走常量 field-index 分发 lowering，而不是继续停在 generic unsupported；driver 的 library/program build 回归也已同步把 tuple 成功路径纳入现有 success matrix，并把旧的 tuple rejection case 收回到真正仍未开放的 non-fixed-shape iterable。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/125_async_main_tuple_for_await.ql、126_async_main_task_tuple_for_await.ql：本轮继续把 fixed-shape iterable public surface 推到真实 executable。新增两条 committed executable examples 分别锁住 homogeneous tuple scalar iterable for await 与 homogeneous task-tuple auto-await for await 两条 async fn main build-and-run 路径；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/127_async_main_import_alias_helper_task_tuple_for_await.ql、128_async_main_projected_task_tuple_for_await.ql、129_async_main_awaited_aggregate_task_tuple_for_await.ql、130_async_main_awaited_tuple_projected_task_tuple_for_await.ql：本轮继续把 homogeneous task-tuple for await public surface 向“已实现但尚未公开锁定”的 place-root 组合扩面。新增四条 committed executable examples 分别锁住 same-file import alias + helper-returned task-tuple root、projected struct-field task-tuple root、awaited aggregate task-tuple root，以及 awaited tuple-projected task-tuple root；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42 / 42 / 42。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/131_async_main_import_alias_awaited_aggregate_task_tuple_for_await.ql、132_async_main_inline_awaited_task_tuple_for_await.ql、133_async_main_awaited_nested_aggregate_task_tuple_for_await.ql、134_async_main_awaited_array_projected_task_tuple_for_await.ql：本轮继续把 homogeneous task-tuple for await public surface 向 mirror paths 扩面。新增四条 committed executable examples 分别锁住 same-file import-alias awaited-aggregate task-tuple root、inline-awaited task-tuple root、awaited nested-aggregate task-tuple root，以及 awaited array-projected task-tuple root；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 42 / 42 / 42。
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/135_async_main_import_alias_task_tuple_for_await.ql、136_async_main_void_task_tuple_for_await.ql：本轮继续把 homogeneous task-tuple for await public surface 收口到剩余高价值 mirror paths。新增两条 committed executable examples 分别锁住 same-file import-alias direct task-tuple root，以及 Task[Void] task-tuple wildcard；它们都已在真实本地 toolchain 下 build-and-run 成功，并稳定退出 42 / 2。至此，task-tuple for await 的 executable public surface 已补齐与 task-array slice 对齐的 direct/import-alias/wildcard/awaited/projected 组合矩阵。
当前边界已更新为 fixed-shape iterable：library-mode 与当前 llvm-ir / object / executable async fn main 子集都可使用 fixed-array + homogeneous tuple 的 for await lowering；更广义的 dynamic/generalized iterable 与更广 program bootstrap 仍保持关闭

P7.4 Task 3（进行中）：扩大 executable async payload 的 regression-locked 子集

crates/ql-codegen-llvm/src/lib.rs：新增 program-mode 单测 emits_async_main_entry_lifecycle_with_tuple_task_handle_payload_in_program_mode、emits_async_main_entry_lifecycle_with_array_task_handle_payload_in_program_mode、emits_async_main_entry_lifecycle_with_nested_aggregate_task_handle_payload_in_program_mode
crates/ql-driver/src/build.rs：新增 executable 成功回归，覆盖 tuple / fixed-array / nested aggregate task-handle payload 在 async fn main 内的成功构建路径
crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_task_handle_tuple_payload.ql、async_program_main_task_handle_array_payload.ql、async_program_main_nested_aggregate_task_handle_payload.ql：补齐 CLI 黑盒 fixture，把这三类 executable program-mode payload 路径正式纳入 pass matrix
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_helper_task_handle_flows.ql：新增 program-mode helper task-handle 综合回归，锁住 await schedule()、bound helper handle、spawn schedule()、forwarded helper handle 与 spawn forward(task) 这五条 executable 路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_direct_handle.ql：新增 program-mode direct task-handle 回归，锁住 let first_task = worker(1); let second_task = worker(2); await first_task; await second_task 这类 direct-local task-handle 路径在 executable 下的连续成功构建
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_spawn_bound_task_handle.ql：新增 program-mode bound task-handle spawn 回归，锁住 let first_task = worker(1); let second_task = worker(2); let second_running = spawn second_task; await second_running 这类 direct-local task-handle 在 executable 下经由 spawn -> await running 的连续成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_local_return_task_handle.ql、async_program_main_local_return_zero_sized_task_handle.ql：新增 program-mode local-return helper task-handle 回归，锁住 fn schedule() -> Task[...] { let task = worker(); return task } 这类 helper 在 executable 下经由 await schedule() 的 regular / zero-sized 两条成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_helper_task_handle_flows.ql：新增 program-mode zero-sized helper task-handle 综合回归，锁住 Task[Wrap]（其中 Wrap 仅含 zero-sized fixed-array 字段）经由 direct helper await、bound helper handle、spawn schedule()、forwarded helper handle 与 spawn forward(task) 这五条 executable 路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aggregate_results.ql：新增 program-mode 非零尺寸 aggregate-result 回归，锁住 tuple / fixed-array / struct 三种 direct await 结果布局在 executable 下的组合成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_spawned_aggregate_results.ql：新增 program-mode spawned 非零尺寸 aggregate-result 回归，锁住 tuple / fixed-array / struct 三种结果布局在 executable 下经由 spawn -> await 的组合成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_recursive_aggregate_results.ql：新增 program-mode 递归 aggregate-result 回归，锁住 (Pair, [Int; 2]) 这类 nested loadable aggregate 在 executable 下经由 direct await 的成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_spawned_recursive_aggregate_results.ql：新增 program-mode spawned 递归 aggregate-result 回归，锁住 (Pair, [Int; 2]) 这类 nested loadable aggregate 在 executable 下经由 spawn -> await 的成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_aggregate_results.ql、async_program_main_spawn_zero_sized_aggregate_result.ql：新增 program-mode zero-sized aggregate-result 回归，锁住 [Int; 0] / Wrap { values: [Int; 0] } 这类 zero-sized loadable result 在 executable 下经由 direct await 与 direct spawn worker() 两条成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_recursive_aggregate_params.ql、async_program_main_zero_sized_aggregate_params.ql：新增 program-mode aggregate-parameter 回归，锁住 recursive aggregate 参数与 zero-sized aggregate 参数在 executable 下经由 direct await 的成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_spawned_recursive_aggregate_params.ql：新增 program-mode spawned 递归 aggregate-parameter 回归，锁住 spawn worker(Pair { left: 1, right: 2 }, [3, 4]) 这类 nested fixed-shape aggregate 参数在 executable 下经由 spawn -> await 的成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_spawned_zero_sized_aggregate_params.ql：新增 program-mode spawned zero-sized aggregate-parameter 回归，锁住 spawn worker([], Wrap { values: [] }, [[]]) 这类 zero-sized fixed-shape aggregate 参数在 executable 下经由 spawn -> await 的成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_projected_task_handle_awaits.ql：新增 program-mode projected task-handle await 回归，锁住 local tuple index、fixed-array literal index 与 struct-field projection 三种 Task[Int] await 路径在 executable 下的连续成功构建
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_projected_task_handle_spawns.ql：新增 program-mode projected task-handle spawn 回归，锁住 local tuple index、fixed-array literal index 与 struct-field projection 三种 Task[Int] 先 spawn 再 await running 路径在 executable 下的连续成功构建
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_projected_task_handle_reinit.ql：新增 program-mode projected task-handle direct reinit 回归，锁住 local tuple index、fixed-array literal index 与 struct-field projection 三种 Task[Int] 在 await 后重赋值、再二次 await 的 executable 成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_projected_task_handle_conditional_reinit.ql：新增 program-mode projected task-handle conditional reinit 回归，锁住 fixed-array literal index Task[Int] 在 if flag { await tasks[0]; tasks[0] = worker(7) } await tasks[0] 这类 branch-join 路径下的 executable 成功构建
crates/ql-borrowck/tests/ownership.rs / crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_library_projected_dynamic_array_reinit.ql、async_library_projected_dynamic_array_conditional_reinit.ql、async_program_main_projected_dynamic_task_handle_reinit.ql、async_program_main_projected_dynamic_task_handle_conditional_reinit.ql：新增 projected dynamic task-handle reinit / conditional reinit 回归，显式锁住 same immutable stable index path（例如 slot.value）在 library-mode 与 program-mode 下经由 await -> reinit -> await、以及 branch-join conditional reinit 的成功构建路径；本轮又补上 same-file const-backed 版本，确认 const INDEX: Int = 0 / const SLOT: Slot = Slot { value: 0 } 也能分别稳定命中 literal reuse 与 projected reinit 合同；CLI 也新增了单独的定向测试入口，后续无需每次重跑整组 codegen snapshot matrix
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_nested_task_handle.ql、async_program_main_zero_sized_struct_task_handle_payload.ql：新增 program-mode zero-sized nested / struct aggregate task-handle 回归，锁住 Task[Wrap] 的 chained-await 路径，以及 Pending { first: Task[Wrap], second: Task[Wrap] } 这类 aggregate-carried task-handle 在 executable 下的连续 await 路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_projected_task_handle_awaits.ql：新增 program-mode zero-sized projected task-handle await 回归，锁住 local tuple index、fixed-array literal index 与 struct-field projection 三种 Task[Wrap] await 路径在 executable 下的连续成功构建
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_projected_task_handle_spawns.ql：新增 program-mode zero-sized projected task-handle spawn 回归，锁住 local tuple index、fixed-array literal index 与 struct-field projection 三种 Task[Wrap] 先 spawn 再 await running 路径在 executable 下的连续成功构建
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_projected_task_handle_reinit.ql：新增 program-mode zero-sized projected task-handle direct reinit 回归，锁住 local tuple index、fixed-array literal index 与 struct-field projection 三种 Task[Wrap] 在 await 后重赋值、再二次 await 的 executable 成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_projected_task_handle_conditional_reinit.ql：新增 program-mode zero-sized projected task-handle conditional reinit 回归，锁住 fixed-array literal index Task[Wrap] 在 if flag { await tasks[0]; tasks[0] = worker() } await tasks[0] 这类 branch-join 路径下的 executable 成功构建
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_branch_spawned_reinit.ql：新增 program-mode regular-size direct-local branch spawned reinit 回归，锁住 var task = worker(); if flag { let running = spawn task; task = fresh_worker(); return await running } else { task = fresh_worker() } return await task 这类 executable 成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_branch_spawned_reinit.ql：新增 program-mode zero-sized direct-local branch spawned reinit 回归，锁住 var task = worker(); if flag { let running = spawn task; task = fresh_worker(); return await running } else { task = fresh_worker() } return await task 这类 executable 成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_reverse_branch_spawned_reinit.ql：新增 program-mode zero-sized direct-local reverse-branch spawned reinit 回归，锁住 var task = worker(); if flag { task = fresh_worker() } else { let running = spawn task; task = fresh_worker(); return await running } return await task 这类 executable 成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_conditional_async_call_spawns.ql：新增 program-mode regular-size conditional async-call spawn 回归，锁住 async fn choose(flag: Bool) -> Int { if flag { let running = spawn worker(); return await running } return await worker() } 及其 reverse-branch 组合在 executable 下的连续成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_conditional_async_call_spawns.ql：新增 program-mode zero-sized conditional async-call spawn 回归，锁住 async fn choose(flag: Bool) -> Wrap { if flag { let running = spawn worker(); return await running } return await worker() } 及其 reverse-branch 组合在 executable 下的连续成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_conditional_helper_task_handle_spawns.ql：新增 program-mode regular-size conditional helper-task-handle spawn 回归，锁住 async fn choose(flag: Bool, task: Task[Int]) -> Int { if flag { let running = spawn task; return await running } return await task } 及其 reverse-branch helper 组合在 executable 下的连续成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_zero_sized_conditional_helper_task_handle_spawns.ql：新增 program-mode zero-sized conditional helper-task-handle spawn 回归，锁住 async fn choose(flag: Bool, task: Task[Wrap]) -> Wrap { if flag { let running = spawn task; return await running } return await task } 及其 reverse-branch helper 组合在 executable 下的连续成功构建路径
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guard_refined_dynamic_task_handle_reinit.ql：本轮把最小 equality-guard dynamic-index refinement 明确接进当前 async program build surface。当前受支持形态是“async fn main 调用 internal async helper，而 helper 内使用 if index == 0 { await tasks[index]; tasks[0] = worker(...) } return await tasks[0] 这类 guarded literal reinit” 的 program subset；llvm-ir / obj / exe 三个 emit 现在都已有定向构建回归。同时 ql-codegen-llvm 还补了一条更小的实现修正：当 statement-position control-flow temp 本身是 Void 时，backend 仍会保留 rvalue side effects，但不再额外生成 dead store，从而避免这类 guarded helper path 产出带 undefined local 的无效 LLVM IR
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guard_refined_dynamic_task_handle_reinit.ql、async_program_main_guard_refined_projected_dynamic_task_handle_reinit.ql：本轮把最小 equality-guard dynamic-index refinement 继续扩到 direct projected program path。当前 async fn main 下的 direct slot.value == 0 projected guard path，与经由 internal async helper body 进入的 direct index == 0 guard path，都已经进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵；这说明 equality-guard refinement 在 program mode 下不只停留于 helper-body 子集，也已覆盖 direct main 里的 stable projected source path。同时 ql-codegen-llvm 上轮补的更小实现修正继续生效：当 statement-position control-flow temp 本身是 Void 时，backend 仍会保留 rvalue side effects，但不再额外生成 dead store，从而避免这类 guarded path 产出带 undefined local 的无效 LLVM IR
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_projected_root_dynamic_task_handle_reinit.ql：本轮继续补齐 aggregate projected-root program path 的 emit parity。当前 async fn main 下的 await pending.tasks[slot.value]; pending.tasks[slot.value] = worker(first + 1); await pending.tasks[slot.value] 现在也已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，说明 projected-root dynamic task-handle reinit 不再只在 exe 端到端路径上被隐式覆盖，而已作为当前 async program subset 的显式 public contract 固化下来
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/10_async_main_guard_refined_projected_root.ql：本轮再把这两条 program path 提升到真实运行样例层。新样例把 helper-based direct if index == 0 { await tasks[index]; tasks[0] = ... } 与 direct projected-root await pending.tasks[slot.value]; pending.tasks[slot.value] = ... 组合到同一条 async fn main，并在真实 toolchain 下锁定退出码 49，保证最新开放的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_projected_root_const_backed_dynamic_task_handle_reinit.ql、tests/codegen/pass/async_program_main_projected_root_const_backed_dynamic_task_handle_reinit.ll：本轮继续把 const-backed projected-root program path 收口成显式 public contract。当前 async fn main 下的 await pending.tasks[INDEX]; pending.tasks[0] = worker(first + 3); await pending.tasks[INDEX] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，并补上独立 LLVM IR snapshot，确认 same-file const item 驱动的 projected-root literal reuse 不会再只靠 shared lowering 被“顺带覆盖”
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/11_async_main_const_backed_projected_root.ql：本轮再把 const-backed projected-root program path 提升到真实运行样例层。新样例单独锁住 await pending.tasks[INDEX]; pending.tasks[0] = ...; await pending.tasks[INDEX] 与 sibling await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 24，保证最新开放的 const-backed projected-root executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_dynamic_task_handle_reinit.ql、tests/codegen/pass/async_program_main_aliased_projected_root_dynamic_task_handle_reinit.ll：本轮继续把 projected-root alias-root canonicalization 补进 program-mode public contract。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 4); let second = await alias[slot.value] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，并修复了 backend 之前把 alias 当作独立 aggregate copy 读取、导致真实 executable 运行时崩溃的问题
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/12_async_main_aliased_projected_root.ql：本轮再把 projected-root alias-root canonicalization 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; await alias[slot.value] 与 sibling await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 17，保证 source-root reinit 恢复 alias 可用性的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_const_backed_dynamic_task_handle_reinit.ql、tests/codegen/pass/async_program_main_aliased_projected_root_const_backed_dynamic_task_handle_reinit.ll：本轮继续把 const-backed projected-root alias-root program path 收口成显式 public contract。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[INDEX]; pending.tasks[0] = worker(first + 2); let second = await alias[INDEX] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item 驱动的 literal reuse 在 alias-root projected-root 形态下也已稳定走通 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/13_async_main_aliased_const_backed_projected_root.ql：本轮再把 const-backed projected-root alias-root path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[INDEX]; pending.tasks[0] = ...; await alias[INDEX] 与 sibling await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 17，保证这条 alias-root + const-backed executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_projected_root_dynamic_task_handle_reinit.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_projected_root_dynamic_task_handle_reinit.ll：本轮继续把 guard-refined projected-root alias-root program path 收口成显式 public contract。当前 async fn main 下的 let alias = pending.tasks; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 3) } let second = await alias[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 equality-guard refinement 与 alias-root canonicalization 在 aggregate field root 上不会重新分叉
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/14_async_main_aliased_guard_refined_projected_root.ql：本轮再把 guard-refined projected-root alias-root path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } await alias[0] 与 sibling await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 21，保证这条 alias-root + guard-refined executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_dynamic_task_handle_reinit.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_dynamic_task_handle_reinit.ll：本轮继续把 const-backed + guard-refined projected-root alias-root program path 收口成显式 public contract。当前 async fn main 下的 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 4) } let second = await alias[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement 与 alias-root canonicalization 三者组合已稳定走通 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/15_async_main_aliased_guard_refined_const_backed_projected_root.ql：本轮再把 const-backed + guard-refined projected-root alias-root path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } await alias[0] 与 sibling await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 25，保证这条三者组合的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/73_async_main_aliased_guard_refined_static_alias_backed_projected_root.ql：本轮再把 static/use-alias-backed + guard-refined projected-root alias-root path 提升到真实运行样例层。新样例单独锁住 use SLOT as INDEX_ALIAS; let alias = pending.tasks; if INDEX_ALIAS.value == 0 { await alias[INDEX_ALIAS.value]; pending.tasks[0] = ... } await alias[0] 与 sibling await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 35，保证这条 static/use-alias + guard-refined 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/74_async_main_aliased_guard_refined_static_alias_backed_nested_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 nested aggregate submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let alias = pending.tasks; if INDEX_ALIAS.value == 0 { await alias[INDEX_ALIAS.value]; pending.tasks[0] = ... } let env = Envelope { bundle: Bundle { left: alias[INDEX_ALIAS.value], right: worker(12) }, tail: pending.tasks[1] }; let running = spawn env.bundle.left 与 await running / await env.bundle.right / await env.tail 的组合，在真实 toolchain 下锁定退出码 42，保证这条 static/use-alias + guard-refined + nested aggregate submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/75_async_main_aliased_guard_refined_static_alias_backed_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let alias = pending.tasks; if INDEX_ALIAS.value == 0 { await alias[INDEX_ALIAS.value]; pending.tasks[0] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[INDEX_ALIAS.value]), worker(24)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 58，保证这条 static/use-alias + guard-refined + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/76_async_main_guarded_static_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row = INDEX_ALIAS.value; let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; if INDEX_ALIAS.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(27)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 65，保证这条 static/use-alias + guard-refined + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/77_async_main_guarded_static_alias_backed_double_root_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 double-root alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row = INDEX_ALIAS.value; let slots = [row, row]; let alias_slots = slots; let root = pending.tasks; let alias = root; if INDEX_ALIAS.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(29)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 69，保证这条 static/use-alias + guard-refined + double-root alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/78_async_main_guarded_static_alias_backed_double_root_double_source_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 double-root double-source alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row = INDEX_ALIAS.value; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let alias = root; if INDEX_ALIAS.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(30)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 71，保证这条 static/use-alias + guard-refined + double-root alias + double-source alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/79_async_main_guarded_static_alias_backed_double_root_double_source_row_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 double-root double-source row alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row_root = INDEX_ALIAS.value; let row = row_root; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let alias = root; if INDEX_ALIAS.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(31)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 73，保证这条 static/use-alias + guard-refined + double-root alias + double-source alias + row alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/80_async_main_guarded_static_alias_backed_double_root_double_source_row_slot_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 double-root double-source row/slot alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row_root = INDEX_ALIAS.value; let row = row_root; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let alias = root; let slot = Slot { value: INDEX_ALIAS.value }; let slot_alias = slot; if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(34)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 77，保证这条 static/use-alias + guard-refined + double-root alias + double-source alias + row alias + slot alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/81_async_main_guarded_static_alias_backed_triple_root_double_source_row_slot_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root double-source row/slot alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row_root = INDEX_ALIAS.value; let row = row_root; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX_ALIAS.value }; let slot_alias = slot; if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(35)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 79，保证这条 static/use-alias + guard-refined + triple-root alias + double-source alias + row/slot alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/82_async_main_guarded_static_alias_backed_triple_root_triple_source_row_slot_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source row/slot alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row_root = INDEX_ALIAS.value; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX_ALIAS.value }; let slot_alias = slot; if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(36)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 81，保证这条 static/use-alias + guard-refined + triple-root alias + triple-source alias + row/slot alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/83_async_main_guarded_static_alias_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source row/slot/tail alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row_root = INDEX_ALIAS.value; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX_ALIAS.value }; let slot_alias = slot; if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let tail_tasks = pending.tasks; let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(37)] }, tail: tail_tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 84，保证这条 static/use-alias + guard-refined + triple-root alias + triple-source alias + row/slot/tail alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/84_async_main_guarded_static_alias_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_forwarded_alias_nested_array_repackage_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source row/slot/tail alias + forwarded alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let row_root = INDEX_ALIAS.value; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX_ALIAS.value }; let slot_alias = slot; if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(38)] }, tail: tail_tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 86，保证这条 static/use-alias + guard-refined + triple-root alias + triple-source alias + row/slot/tail alias + forwarded alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/85_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queued_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(39)] }, tail: tail_tasks[1] }; let queued = env.bundle.tasks[0]; let running = spawn queued 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 88，保证这条 static/use-alias + guard-refined + queued alias before spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/86_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(40)] }, tail: tail_tasks[1] }; let queued_tasks = env.bundle.tasks; let queued = queued_tasks[0]; let running = spawn queued 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 90，保证这条 static/use-alias + guard-refined + queued-root-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/87_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_alias_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-aliased-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(41)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queued_tasks = queue_root; let queued = queued_tasks[0]; let running = spawn queued 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 92，保证这条 static/use-alias + guard-refined + queued-root-aliased-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/88_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_chain_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-chain-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(42)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let running = spawn queued 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 94，保证这条 static/use-alias + guard-refined + queued-root-chain-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/89_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_alias_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-local-aliased-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(43)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let running = spawn queued_alias 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 96，保证这条 static/use-alias + guard-refined + queued-local-aliased-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/90_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_chain_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-local-chain-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(44)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let running = spawn queued_final 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 98，保证这条 static/use-alias + guard-refined + queued-local-chain-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/91_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_forward_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-local-forwarded-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(45)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let queued_ready = forward(queued_final); let running = spawn queued_ready 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 100，保证这条 static/use-alias + guard-refined + queued-local-forwarded-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/92_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_inline_forward_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-local-inline-forwarded-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(46)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let running = spawn forward(queued_final) 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 102，保证这条 static/use-alias + guard-refined + queued-local-inline-forwarded-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/93_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_inline_forward_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + bundle-inline-forwarded-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(47)] }, tail: tail_tasks[1] }; let running = spawn forward(env.bundle.tasks[0]) 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 104，保证这条 static/use-alias + guard-refined + bundle-inline-forwarded-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/94_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + bundle-slot-inline-forwarded-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(48)] }, tail: tail_tasks[1] }; let bundle_slot = Slot { value: INDEX_ALIAS.value }; let bundle_slot_alias = bundle_slot; let running = spawn forward(env.bundle.tasks[bundle_slot_alias.value]) 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 106，保证这条 static/use-alias + guard-refined + bundle-slot-inline-forwarded-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/95_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_direct_inline_forward_spawn.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + tail-inline-forwarded-before-spawn submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(49)] }, tail: tail_tasks[1] }; let running = spawn forward(env.tail) 与 await env.bundle.tasks[0] / await env.bundle.tasks[1] / await running 的组合，在真实 toolchain 下锁定退出码 108，保证这条 static/use-alias + guard-refined + tail-inline-forwarded-before-spawn + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/96_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_direct_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + tail-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(51)] }, tail: tail_tasks[1] }; let tail = await forward(env.tail) 与 await env.bundle.tasks[0] / await env.bundle.tasks[1] 的组合，在真实 toolchain 下锁定退出码 110，保证这条 static/use-alias + guard-refined + tail-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/97_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + bundle-slot-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(53)] }, tail: tail_tasks[1] }; let bundle_slot = Slot { value: INDEX_ALIAS.value }; let bundle_slot_alias = bundle_slot; let second = await forward(env.bundle.tasks[bundle_slot_alias.value]) 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 112，保证这条 static/use-alias + guard-refined + bundle-slot-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/98_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + bundle-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(55)] }, tail: tail_tasks[1] }; let second = await forward(env.bundle.tasks[0]) 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 114，保证这条 static/use-alias + guard-refined + bundle-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/99_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-local-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(57)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let second = await forward(queued_final) 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 116，保证这条 static/use-alias + guard-refined + queued-local-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/100_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-local-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(59)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let queued_ready = forward(queued_final); let second = await queued_ready 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 118，保证这条 static/use-alias + guard-refined + queued-local-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/101_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(61)] }, tail: tail_tasks[1] }; let queued_tasks = env.bundle.tasks; let second = await forward(queued_tasks[0]) 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 120，保证这条 static/use-alias + guard-refined + queued-root-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/102_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(63)] }, tail: tail_tasks[1] }; let queued_tasks = env.bundle.tasks; let queued = queued_tasks[0]; let queued_ready = forward(queued); let second = await queued_ready 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 122，保证这条 static/use-alias + guard-refined + queued-root-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/103_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_alias_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-aliased-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(64)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queued_tasks = queue_root; let queued = queued_tasks[0]; let queued_ready = forward(queued); let second = await queued_ready 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 124，保证这条 static/use-alias + guard-refined + queued-root-aliased-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/104_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_chain_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-chain-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(65)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_ready = forward(queued); let second = await queued_ready 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 126，保证这条 static/use-alias + guard-refined + queued-root-chain-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/105_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_alias_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-aliased-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(66)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queued_tasks = queue_root; let second = await forward(queued_tasks[0]) 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 128，保证这条 static/use-alias + guard-refined + queued-root-aliased-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/106_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_chain_inline_forward_await.ql：本轮继续把 static/use-alias-backed + guard-refined projected-root alias-root path 推进到 triple-root triple-source tail alias + queued-root-chain-inline-forwarded-before-await submit。新样例单独锁住 use SLOT as INDEX_ALIAS; let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(67)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let second = await forward(queued_tasks[0]) 与 await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 130，保证这条 static/use-alias + guard-refined + queued-root-chain-inline-forwarded-before-await + forwarded alias + tail alias + triple-root/triple-source alias 组合路径不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_tuple_repackage_reinit.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_tuple_repackage_reinit.ll：本轮继续把 alias-fed aggregate repackage 收口进 async program public contract。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 3); let pair = (alias[slot.value], worker(5)); let second = await pair[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 source-root reinit 后的 alias-root projected task handle 不仅能直接再次 await，也能先重新包装进 tuple aggregate 再稳定进入 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/16_async_main_aliased_projected_root_tuple_repackage_reinit.ql：本轮再把 alias-fed tuple repackage path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let pair = (alias[slot.value], worker(5)); await pair[0] 与 await pair[1] / await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 31，保证这条更贴近真实聚合重组写法的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_struct_repackage_reinit.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_struct_repackage_reinit.ll：本轮继续把 alias-fed aggregate repackage 从 tuple 推进到 named struct。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 3); let bundle = Bundle { left: alias[slot.value], right: worker(6) }; let second = await bundle.left 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 source-root reinit 后的 alias-root projected task handle 不仅能被 tuple 重包装，也能稳定进入 struct-field aggregate lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/17_async_main_aliased_projected_root_struct_repackage_reinit.ql：本轮再把 alias-fed struct repackage path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let bundle = Bundle { left: alias[slot.value], right: worker(6) }; await bundle.left 与 await bundle.right / await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 32，保证这条更贴近业务对象封装写法的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_nested_repackage_reinit.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_nested_repackage_reinit.ll：本轮继续把 alias-fed aggregate repackage 从单层 struct 推进到 nested aggregate。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 3); let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(7) }, tail: pending.tasks[1] }; let second = await env.bundle.left 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 source-root reinit 后的 alias-root projected task handle 不仅能被单层 aggregate 重包装，也能稳定进入多层 nested aggregate lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/18_async_main_aliased_projected_root_nested_repackage_reinit.ql：本轮再把 alias-fed nested aggregate repackage path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(7) }, tail: pending.tasks[1] }; await env.bundle.left 与 await env.bundle.right / await env.tail 的组合，在真实 toolchain 下锁定退出码 33，保证这条更贴近真实多层对象封装写法的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_nested_repackage_reinit.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_nested_repackage_reinit.ll：本轮继续把 const-backed + guard-refined + alias-root projected-root 的组合路径推进到 nested aggregate repackage。当前 async fn main 下的 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 5) } let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(9) }, tail: pending.tasks[1] } 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement、alias-root canonicalization 与 nested aggregate repackage 四者组合已稳定走通 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/19_async_main_aliased_guard_refined_const_backed_nested_repackage_reinit.ql：本轮再把上述组合 path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(9) }, tail: pending.tasks[1] }; await env.bundle.left 与 await env.bundle.right / await env.tail 的组合，在真实 toolchain 下锁定退出码 36，保证这条更贴近真实复杂对象封装写法的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_nested_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_nested_repackage_spawn.ll：本轮继续把 alias-fed nested aggregate repackage 从 direct await 推进到 spawn -> await running。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 4); let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(7) }, tail: pending.tasks[1] }; let running = spawn env.bundle.left 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 source-root reinit 后再经 nested aggregate 重包装的 task handle 不仅能被直接 await，也能稳定进入 program-mode submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/20_async_main_aliased_projected_root_nested_repackage_spawn.ql：本轮再把 alias-fed nested aggregate repackage spawn path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(7) }, tail: pending.tasks[1] }; let running = spawn env.bundle.left 与 await running / await env.bundle.right / await env.tail 的组合，在真实 toolchain 下锁定退出码 34，保证这条更贴近真实任务提交流程的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_nested_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_nested_repackage_spawn.ll：本轮继续把 const-backed + guard-refined + alias-root projected-root 的组合路径推进到 nested aggregate submit。当前 async fn main 下的 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 5) } let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(11) }, tail: pending.tasks[1] }; let running = spawn env.bundle.left 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement、alias-root canonicalization、nested aggregate repackage 与 submit lowering 五者组合已稳定走通 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/21_async_main_aliased_guard_refined_const_backed_nested_repackage_spawn.ql：本轮再把上述组合 path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } let env = Envelope { bundle: Bundle { left: alias[slot.value], right: worker(11) }, tail: pending.tasks[1] }; let running = spawn env.bundle.left 与 await running / await env.bundle.right / await env.tail 的组合，在真实 toolchain 下锁定退出码 38，保证这条更贴近真实复杂任务提交流程的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_array_repackage_spawn.ll：本轮继续把 alias-root repackage 补齐到 fixed-array aggregate 形态。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 4); let tasks = [alias[slot.value], worker(10)]; let running = spawn tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 source-root reinit 后再经 fixed-array 重包装的 task handle 也能稳定进入 program-mode submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/22_async_main_aliased_projected_root_array_repackage_spawn.ql：本轮再把 alias-fed fixed-array repackage spawn path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let tasks = [alias[slot.value], worker(10)]; let running = spawn tasks[0] 与 await running / await tasks[1] / await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 37，保证这条 array aggregate 形态的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_array_repackage_spawn.ll：本轮继续把 const-backed + guard-refined + alias-root projected-root 的组合路径推进到 fixed-array submit。当前 async fn main 下的 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 5) } let tasks = [alias[slot.value], worker(13)]; let running = spawn tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement、alias-root canonicalization、fixed-array repackage 与 submit lowering 五者组合也已稳定走通 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/23_async_main_aliased_guard_refined_const_backed_array_repackage_spawn.ql：本轮再把上述组合 path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } let tasks = [alias[slot.value], worker(13)]; let running = spawn tasks[0] 与 await running / await tasks[1] / await pending.tasks[1] 的组合，在真实 toolchain 下锁定退出码 40，保证这条 fixed-array 形态的组合 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_nested_array_repackage_spawn.ll：本轮继续把 alias-root repackage 从单层 fixed-array submit 推进到 nested aggregate 内含 fixed-array 的 submit 形态。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 6); let env = Envelope { bundle: Bundle { tasks: [alias[slot.value], worker(12)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 source-root reinit 后的 task handle 不仅能直接重包装进 array 并提交，也能再经过 struct field 包裹后稳定进入 nested submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/24_async_main_aliased_projected_root_nested_array_repackage_spawn.ql：本轮再把上述 nested-array submit path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let env = Envelope { bundle: Bundle { tasks: [alias[slot.value], worker(12)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 41，保证这条 nested fixed-array aggregate 形态的 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_nested_array_repackage_spawn.ll：本轮继续把 const-backed + guard-refined + alias-root 的组合路径推进到 nested fixed-array submit。当前 async fn main 下的 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 7) } let env = Envelope { bundle: Bundle { tasks: [alias[slot.value], worker(17)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement、alias-root canonicalization 与 nested fixed-array submit lowering 的组合也已稳定走通 program-mode lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/25_async_main_aliased_guard_refined_const_backed_nested_array_repackage_spawn.ql：本轮再把上述 guarded nested-array submit path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } let env = Envelope { bundle: Bundle { tasks: [alias[slot.value], worker(17)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 46，保证这条 nested fixed-array 组合 executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_composed_dynamic_task_handle_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_composed_dynamic_task_handle_nested_array_repackage_spawn.ll：本轮继续把 stable-dynamic path 的递归组合推进到 nested fixed-array submit。当前 async fn main 下的 let row = choose(); let slots = [row, row]; let alias = pending.tasks; let first = await alias[slots[row]]; pending.tasks[slots[row]] = worker(first + 6); let env = Envelope { bundle: Bundle { tasks: [alias[slots[row]], worker(18)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 composed stable-dynamic path 不只支持 direct reinit，也能稳定流经 nested fixed-array aggregate 后进入 submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/26_async_main_composed_dynamic_nested_array_repackage_spawn.ql：本轮再把上述 composed nested-array submit path 提升到真实运行样例层。新样例单独锁住 let row = choose(); let slots = [row, row]; let alias = pending.tasks; await alias[slots[row]]; pending.tasks[slots[row]] = ...; let env = Envelope { bundle: Bundle { tasks: [alias[slots[row]], worker(18)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 47，保证这条 composed dynamic + nested fixed-array executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_alias_sourced_composed_dynamic_task_handle_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_alias_sourced_composed_dynamic_task_handle_nested_array_repackage_spawn.ll：本轮继续把 alias-sourced composed stable-dynamic path 推进到 nested fixed-array submit。当前 async fn main 下的 let row = choose(); let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 6); let env = Envelope { bundle: Bundle { tasks: [alias[alias_slots[row]], worker(19)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 composed dynamic source path 即使再经一层 immutable alias，也能稳定流经 nested fixed-array aggregate 后进入 submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/27_async_main_alias_sourced_composed_dynamic_nested_array_repackage_spawn.ql：本轮再把上述 alias-sourced nested-array submit path 提升到真实运行样例层。新样例单独锁住 let row = choose(); let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; await alias[alias_slots[row]]; pending.tasks[slots[row]] = ...; let env = Envelope { bundle: Bundle { tasks: [alias[alias_slots[row]], worker(19)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 48，保证这条 alias-sourced composed dynamic + nested fixed-array executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_alias_sourced_composed_dynamic_task_handle_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_alias_sourced_composed_dynamic_task_handle_nested_array_repackage_spawn.ll：本轮继续把 const-backed + guard-refined 推进到 alias-sourced composed stable-dynamic nested-array submit。当前 async fn main 下的 let row = choose(); let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 8) } let env = Envelope { bundle: Bundle { tasks: [alias[alias_slots[row]], worker(20)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement 与 alias-sourced composed stable-dynamic path 的组合也能稳定流经 nested fixed-array aggregate 后进入 submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/28_async_main_guarded_alias_sourced_composed_dynamic_nested_array_repackage_spawn.ql：本轮再把上述 guarded alias-sourced nested-array submit path 提升到真实运行样例层。新样例单独锁住 let row = choose(); let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... } let env = Envelope { bundle: Bundle { tasks: [alias[alias_slots[row]], worker(20)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 50，保证这条 const/guard + alias-sourced composed dynamic + nested fixed-array executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_projected_root_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_projected_root_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 helper task-handle surface 推进到 nested fixed-array submit。当前 async fn main 下的 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 8); let env = Envelope { bundle: Bundle { tasks: [forward(alias[slot.value]), worker(21)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 helper-argument task-handle flow 不只支持 direct local / direct aggregate submit，也能稳定流经 nested fixed-array aggregate 后进入 submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/29_async_main_aliased_projected_root_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 helper-forwarded nested-array submit path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; let env = Envelope { bundle: Bundle { tasks: [forward(alias[slot.value]), worker(21)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 52，保证这条 helper task-handle + nested fixed-array executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_aliased_guard_refined_const_backed_projected_root_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 const-backed + guard-refined 推进到 helper-forwarded nested-array submit。当前 async fn main 下的 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[slot.value]; pending.tasks[0] = worker(first + 9) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[slot.value]), worker(23)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 现已进入 llvm-ir / obj / exe 三个 emit 的定向构建矩阵，确认 same-file const item、dominated-branch literal refinement 与 helper-forwarded task-handle flow 的组合也能稳定流经 nested fixed-array aggregate 后进入 submit lowering
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/30_async_main_aliased_guard_refined_const_backed_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 guarded helper-forwarded nested-array submit path 提升到真实运行样例层。新样例单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } let env = Envelope { bundle: Bundle { tasks: [forward(alias[slot.value]), worker(23)] }, tail: pending.tasks[1] }; let running = spawn env.bundle.tasks[0] 与 await running / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 54，保证这条 const/guard + helper task-handle + nested fixed-array executable subset 不只“可构建”，而且已有 committed build-and-run smoke
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn_with_tail_field.ql、tests/codegen/pass/async_program_main_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn_with_tail_field.ll：本轮把 alias-sourced composed stable-dynamic 继续推进到 helper-forwarded nested-array submit，但先明确锁在 sibling task field 这条已可证明安全的边界内。当前 async fn main 下的 let row = choose(); let slots = [row, row]; let alias_slots = slots; var pending = Pending { tasks: [...], tail: worker(17) }; let alias = pending.tasks; let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 9); let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(24)] }, tail: pending.tail }; let running = spawn env.bundle.tasks[0] 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 helper-argument consume 在 alias-sourced composed-dynamic path 上已能与 sibling task field 并存，不再只局限于 direct-local 或 projected-root 形态
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/31_async_main_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn_with_tail_field.ql：本轮再把上述 alias-sourced composed-dynamic helper-forwarded path 提升到真实运行样例层。新样例单独锁住 forward(alias[alias_slots[row]])、pending.tasks[slots[row]] = ...、tail: pending.tail 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 59，保证这条 helper task-handle + alias-sourced composed dynamic + sibling task field + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn_with_tail_field.ql、tests/codegen/pass/async_program_main_guarded_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn_with_tail_field.ll：本轮继续把 same-file const item 与 dominated-branch literal refinement 叠加到上述 helper-forwarded sibling-field path。当前 async fn main 下的 let row = choose(); let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 10) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(26)] }, tail: pending.tail } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 const/guard refinement 与 alias-sourced composed-dynamic helper-forwarded task-handle flow 也能稳定并存于 sibling task field 形态
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/32_async_main_guarded_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn_with_tail_field.ql：本轮再把上述 guarded alias-sourced composed-dynamic helper-forwarded path 提升到真实运行样例层。新样例单独锁住 if slot.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tail 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 63，保证这条 const/guard + helper task-handle + alias-sourced composed-dynamic + sibling task field + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_const_backed_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_const_backed_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮把 helper-forwarded alias-sourced composed-dynamic path 进一步推进回同数组兄弟元素形态，但先锁在 same-file const-backed index 这条已可证明稳定的边界内。当前 async fn main 下的 let row = INDEX; let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 11); let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(27)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 same-file const item 足以把 helper-consumed alias-sourced composed-dynamic path 精确折回 sibling array element 可用路径
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/33_async_main_const_backed_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 const-backed alias-sourced composed-dynamic helper-forwarded path 提升到真实运行样例层。新样例单独锁住 row = INDEX、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 61，保证这条 helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 dominated-branch literal refinement 叠加到上述 same-file const-backed sibling-array path。当前 async fn main 下的 let row = INDEX; let slots = [row, row]; let alias_slots = slots; let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 12) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(28)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 const/guard refinement 也能与 same-file const-backed alias-sourced composed-dynamic helper-forwarded sibling-array path 稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/34_async_main_guarded_const_backed_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 guarded const-backed alias-sourced composed-dynamic helper-forwarded path 提升到真实运行样例层。新样例单独锁住 if slot.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、row = INDEX、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 62，保证这条 const/guard + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_double_root_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_double_root_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 task-handle root alias canonicalization 叠加到上述 guarded const-backed sibling-array path。当前 async fn main 下的 let row = INDEX; let slots = [row, row]; let alias_slots = slots; let root = pending.tasks; let alias = root; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 13) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(29)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 root alias canonicalization 在 helper-forwarded alias-sourced composed-dynamic sibling-array path 上再多一层 immutable alias 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/35_async_main_guarded_const_backed_double_root_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 double-root alias guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let root = pending.tasks; let alias = root、if slot.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 64，保证这条 const/guard + double-root alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_double_root_double_source_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_double_root_double_source_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 composed stable-dynamic source path 的 source-side alias canonicalization 再叠加一层 immutable hop。当前 async fn main 下的 let row = INDEX; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let alias = root; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 14) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(30)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 source-side immutable alias 再多一层时，helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/36_async_main_guarded_const_backed_double_root_double_source_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 double-root + double-source alias guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let slot_root = slots; let alias_slots = slot_root、let root = pending.tasks; let alias = root、if slot.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 66，保证这条 const/guard + double-root alias + double-source alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_double_root_double_source_row_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_double_root_double_source_row_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 stable-dynamic source path 的最前端索引源再叠加一层 immutable row alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let alias = root; let slot = Slot { value: INDEX }; if slot.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 15) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(31)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认最前端 row source 再多一层 immutable alias 时，这条 helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/37_async_main_guarded_const_backed_double_root_double_source_row_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 row-aliased guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let row_root = INDEX; let row = row_root、let slot_root = slots; let alias_slots = slot_root、let root = pending.tasks; let alias = root、if slot.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 68，保证这条 const/guard + row alias + double-root alias + double-source alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_double_root_double_source_row_slot_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_double_root_double_source_row_slot_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 equality guard source 再叠加一层 immutable slot alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let alias = root; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 16) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(34)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 guard source 再多一层 immutable alias 时，这条 helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/38_async_main_guarded_const_backed_double_root_double_source_row_slot_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 slot-aliased guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let slot = Slot { value: INDEX }; let slot_alias = slot、let row_root = INDEX; let row = row_root、let slot_root = slots; let alias_slots = slot_root、let root = pending.tasks; let alias = root、if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 72，保证这条 const/guard + slot alias + row alias + double-root alias + double-source alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_double_source_row_slot_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_double_source_row_slot_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 task-handle root alias canonicalization 再叠加一层 immutable alias hop。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let alias_slots = slot_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 17) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(35)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 task-handle root 再多一层 immutable alias 时，这条 helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/39_async_main_guarded_const_backed_triple_root_double_source_row_slot_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 triple-root guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let root = pending.tasks; let root_alias = root; let alias = root_alias、let slot = Slot { value: INDEX }; let slot_alias = slot、let row_root = INDEX; let row = row_root、let slot_root = slots; let alias_slots = slot_root、if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 74，保证这条 const/guard + triple-root alias + slot alias + row alias + double-source alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_row_slot_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_row_slot_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 source-side alias chain 再叠加一层 immutable alias hop。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 18) } let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(36)] }, tail: pending.tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 source-side alias 再多一层 immutable alias 时，这条 helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/40_async_main_guarded_const_backed_triple_root_triple_source_row_slot_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 triple-source guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root、let root = pending.tasks; let root_alias = root; let alias = root_alias、let slot = Slot { value: INDEX }; let slot_alias = slot、let row_root = INDEX; let row = row_root、if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: pending.tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 76，保证这条 const/guard + triple-source alias + triple-root alias + row/slot alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_task_handle_forwarded_nested_array_repackage_spawn.ll：本轮继续把 sibling tail consume path 再叠加一层 immutable alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 19) } let tail_tasks = pending.tasks; let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(37)] }, tail: tail_tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 sibling tail consume path 再多一层 immutable alias 时，这条 helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/41_async_main_guarded_const_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql：本轮再把上述 tail-aliased guarded const-backed helper-forwarded path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root、let root = pending.tasks; let root_alias = root; let alias = root_alias、let slot = Slot { value: INDEX }; let slot_alias = slot、let row_root = INDEX; let row = row_root、if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、forward(alias[alias_slots[row]])、tail: tail_tasks[1] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 78，保证这条 const/guard + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + const-backed alias-sourced composed-dynamic + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_task_handle_forwarded_alias_nested_array_repackage_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_task_handle_forwarded_alias_nested_array_repackage_spawn.ll：本轮继续把 helper 返回 task handle 再叠加一层 immutable forwarded alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 20) } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(38)] }, tail: tail_tasks[1] } 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 helper 返回值再多一层 immutable alias 时，这条 helper-forwarded alias-sourced composed-dynamic sibling-array path 仍能稳定并存
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/42_async_main_guarded_const_backed_triple_root_triple_source_row_slot_tail_alias_sourced_composed_dynamic_forwarded_alias_nested_array_repackage_spawn.ql：本轮再把上述 forwarded-alias guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded、let tail_tasks = pending.tasks、let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root、let root = pending.tasks; let root_alias = root; let alias = root_alias、let slot = Slot { value: INDEX }; let slot_alias = slot、let row_root = INDEX; let row = row_root、if slot_alias.value == 0 { await alias[alias_slots[row]]; pending.tasks[slots[row]] = ... }、tasks: [running_task, worker(38)] 与 spawn env.bundle.tasks[0] / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 80，保证这条 const/guard + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queued_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queued_spawn.ll：本轮继续把 nested fixed-array aggregate 中即将 spawn 的 task handle 再叠加一层 immutable queued alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 21) } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(39)] }, tail: tail_tasks[1] }; let queued = env.bundle.tasks[0]; let running = spawn queued 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested aggregate 中的 helper-forwarded task handle 再多一层 queued alias 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/43_async_main_guarded_const_backed_triple_root_triple_source_tail_queued_spawn.ql：本轮再把上述 queued-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(39)] }, tail: tail_tasks[1] }、let queued = env.bundle.tasks[0] 与 spawn queued / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 82，保证这条 const/guard + queued alias before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_spawn.ll：本轮继续把 queued-before-spawn path 上的 nested fixed-array root 再叠加一层 immutable root alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 22) } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(40)] }, tail: tail_tasks[1] }; let queued_tasks = env.bundle.tasks; let queued = queued_tasks[0]; let running = spawn queued 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued-before-spawn path 上的 nested fixed-array root 再多一层 immutable alias 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/44_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_spawn.ql：本轮再把上述 queued-root-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(40)] }, tail: tail_tasks[1] }、let queued_tasks = env.bundle.tasks、let queued = queued_tasks[0] 与 spawn queued / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 84，保证这条 const/guard + queued root alias before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_spawn.ll：本轮继续把 queued-root-before-spawn path 上的 nested fixed-array root 再叠加一层 immutable alias hop。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 23) } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(41)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queued_tasks = queue_root; let queued = queued_tasks[0]; let running = spawn queued 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued-root-before-spawn path 上的 nested fixed-array root 再多一层 immutable alias 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/45_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_spawn.ql：本轮再把上述 queued-root-aliased-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(41)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queued_tasks = queue_root、let queued = queued_tasks[0] 与 spawn queued / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 86，保证这条 const/guard + queued root alias before spawn 再多一层 immutable alias + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_spawn.ll：本轮继续把 queued-root-before-spawn path 上的 nested fixed-array root 再叠加一层 immutable alias chain。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 24) } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(42)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let running = spawn queued 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued-root-before-spawn path 上的 nested fixed-array root 再多一层 immutable alias chain 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/46_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_spawn.ql：本轮再把上述 queued-root-chain-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(42)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0] 与 spawn queued / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 88，保证这条 const/guard + queued root alias before spawn 再多一层 immutable alias chain + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_alias_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_alias_spawn.ll：本轮继续把 queued-root-before-spawn path 上的 projected task handle 再叠加一层 immutable local alias。当前 async fn main 下的 let row_root = INDEX; let row = row_root; let slots = [row, row]; let slot_root = slots; let slot_alias_root = slot_root; let alias_slots = slot_alias_root; let root = pending.tasks; let root_alias = root; let alias = root_alias; let slot = Slot { value: INDEX }; let slot_alias = slot; if slot_alias.value == 0 { let first = await alias[alias_slots[row]]; pending.tasks[slots[row]] = worker(first + 25) } let tail_tasks = pending.tasks; let forwarded = forward(alias[alias_slots[row]]); let running_task = forwarded; let env = Envelope { bundle: Bundle { tasks: [running_task, worker(43)] }, tail: tail_tasks[1] }; let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let running = spawn queued_alias 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued-root-before-spawn path 上的 projected task handle 再多一层 immutable local alias 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/47_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_alias_spawn.ql：本轮再把上述 queued-local-aliased-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(43)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_alias = queued 与 spawn queued_alias / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 90，保证这条 const/guard + queued local alias before spawn 叠加在 queued-root alias chain 之上 + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_chain_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_chain_spawn.ll：本轮继续把 queued-local-before-spawn path 再叠加一层 immutable local alias hop。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let running = spawn queued_final 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued local alias 链再多一跳后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/48_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_chain_spawn.ql：本轮再把上述 queued-local-chain-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(44)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_alias = queued、let queued_final = queued_alias 与 spawn queued_final / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 92，保证这条 const/guard + queued local chain before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_spawn.ll：本轮继续把 queued-local-before-spawn path 再经过一次 helper 形参/返回值转发。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let queued_ready = forward(queued_final); let running = spawn queued_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued local chain 再经一次 helper-returned task handle 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/49_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_spawn.ql：本轮再把上述 queued-local-forwarded-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(45)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_alias = queued、let queued_final = queued_alias、let queued_ready = forward(queued_final) 与 spawn queued_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 94，保证这条 const/guard + queued local forwarded before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_spawn.ll：本轮继续把 queued-local-before-spawn path 推进到 inline helper-submit。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let running = spawn forward(queued_final) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 queued local chain 再经一次 inline helper-returned task handle 后，这条 composed-dynamic sibling-array path 仍能稳定提交
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/50_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_spawn.ql：本轮再把上述 queued-local-inline-forward-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(46)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_alias = queued、let queued_final = queued_alias 与 spawn forward(queued_final) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 96，保证这条 const/guard + queued local inline forward before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_spawn.ll：本轮继续把 guarded helper-forwarded nested aggregate path 推进到 direct projected helper-submit。当前 async fn main 下的 let env = Envelope { bundle: Bundle { tasks: [running_task, worker(47)] }, tail: tail_tasks[1] }; let running = spawn forward(env.bundle.tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested fixed-array aggregate 中的 projected task handle 现在也能直接作为 helper-returned submit 源，而不必先落到额外 queue local 上
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/51_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_spawn.ql：本轮再把上述 bundle-inline-forward-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(47)] }, tail: tail_tasks[1] } 与 spawn forward(env.bundle.tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 98，保证这条 const/guard + bundle inline forward before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_spawn.ll：本轮继续把 direct projected helper-submit 推进到 stable dynamic projected index。当前 async fn main 下的 let env = Envelope { bundle: Bundle { tasks: [running_task, worker(48)] }, tail: tail_tasks[1] }; let bundle_slot = Slot { value: INDEX }; let bundle_slot_alias = bundle_slot; let running = spawn forward(env.bundle.tasks[bundle_slot_alias.value]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested fixed-array aggregate 中的 projected task handle 现在也能通过稳定动态投影索引直接作为 helper-returned submit 源，而不必退回 literal-only path
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/52_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_spawn.ql：本轮再把上述 bundle-slot-inline-forward-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(48)] }, tail: tail_tasks[1] }、let bundle_slot = Slot { value: INDEX }、let bundle_slot_alias = bundle_slot 与 spawn forward(env.bundle.tasks[bundle_slot_alias.value]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 100，保证这条 const/guard + bundle slot inline forward before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_spawn.ll：本轮继续把 nested aggregate field-root helper-submit 作为单独 public surface 锁住。当前 async fn main 下的 let env = Envelope { bundle: Bundle { tasks: [running_task, worker(49)] }, tail: tail_tasks[1] }; let running = spawn forward(env.tail) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested aggregate 中的 task-handle struct field 现在也能直接作为 helper-returned submit 源，而不必经 array slot 或 queue local 中转
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/53_async_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_spawn.ql：本轮再把上述 tail-inline-forward-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(49)] }, tail: tail_tasks[1] } 与 spawn forward(env.tail) / await env.bundle.tasks[0] / await env.bundle.tasks[1] 的组合，在真实 toolchain 下锁定退出码 102，保证这条 const/guard + tail inline forward before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_await.ll：本轮继续把 nested aggregate field-root helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let env = Envelope { bundle: Bundle { tasks: [running_task, worker(51)] }, tail: tail_tasks[1] }; let tail = await forward(env.tail) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested aggregate 中的 task-handle struct field 现在也能直接作为 helper-returned await 源，而不必先退回 queue local 或显式 spawn
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/54_async_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_await.ql：本轮再把上述 tail-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(51)] }, tail: tail_tasks[1] } 与 await forward(env.tail) / await env.bundle.tasks[0] / await env.bundle.tasks[1] 的组合，在真实 toolchain 下锁定退出码 104，保证这条 const/guard + tail inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_await.ll：本轮继续把 nested aggregate stable-dynamic projected helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let env = Envelope { bundle: Bundle { tasks: [running_task, worker(53)] }, tail: tail_tasks[1] }; let bundle_slot = Slot { value: INDEX }; let bundle_slot_alias = bundle_slot; let second = await forward(env.bundle.tasks[bundle_slot_alias.value]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested fixed-array aggregate 中的 projected task handle 现在也能通过稳定动态投影索引直接作为 helper-returned await 源，而不必退回 literal-only path 或显式 spawn
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/55_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_await.ql：本轮再把上述 bundle-slot-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(53)] }, tail: tail_tasks[1] }、let bundle_slot = Slot { value: INDEX }、let bundle_slot_alias = bundle_slot 与 await forward(env.bundle.tasks[bundle_slot_alias.value]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 106，保证这条 const/guard + bundle slot inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_await.ll：本轮继续把 nested aggregate literal projected helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let env = Envelope { bundle: Bundle { tasks: [running_task, worker(55)] }, tail: tail_tasks[1] }; let second = await forward(env.bundle.tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认 nested fixed-array aggregate 中的 literal projected task handle 现在也能直接作为 helper-returned await 源，而不必显式 spawn 或经稳定动态索引中转
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/56_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_await.ql：本轮再把上述 bundle-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(55)] }, tail: tail_tasks[1] } 与 await forward(env.bundle.tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 108，保证这条 const/guard + bundle inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_await.ll：本轮继续把 queued-local helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let second = await forward(queued_final) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate 中先取出局部 task handle、再经 inline helper-returned await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/57_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_await.ql：本轮再把上述 queued-local-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(57)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_alias = queued、let queued_final = queued_alias 与 await forward(queued_final) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 110，保证这条 const/guard + queued local inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_await.ll：本轮继续把 queued-local helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_alias = queued; let queued_final = queued_alias; let queued_ready = forward(queued_final); let second = await queued_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate 中先取出局部 task handle、再经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/58_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_await.ql：本轮再把上述 queued-local-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(59)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_alias = queued、let queued_final = queued_alias、let queued_ready = forward(queued_final) 与 await queued_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 112，保证这条 const/guard + queued local forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_inline_forward_await.ll：本轮继续把 queued-root projected helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queued_tasks = env.bundle.tasks; let second = await forward(queued_tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 直接投影并经 inline helper-returned await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/59_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_inline_forward_await.ql：本轮再把上述 queued-root-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(61)] }, tail: tail_tasks[1] }、let queued_tasks = env.bundle.tasks 与 await forward(queued_tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 114，保证这条 const/guard + queued root inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_forward_await.ll：本轮继续把 queued-root helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queued_tasks = env.bundle.tasks; let queued = queued_tasks[0]; let queued_ready = forward(queued); let second = await queued_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 投影出局部 task handle、再经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/60_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_forward_await.ql：本轮再把上述 queued-root-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(63)] }, tail: tail_tasks[1] }、let queued_tasks = env.bundle.tasks、let queued = queued_tasks[0]、let queued_ready = forward(queued) 与 await queued_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 116，保证这条 const/guard + queued root forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_forward_await.ll：本轮继续把 queued-root-aliased helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queued_tasks = queue_root; let queued = queued_tasks[0]; let queued_ready = forward(queued); let second = await queued_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经一层 immutable alias、再投影出局部 task handle 并经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/61_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_forward_await.ql：本轮再把上述 queued-root-aliased-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(64)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queued_tasks = queue_root、let queued = queued_tasks[0]、let queued_ready = forward(queued) 与 await queued_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 118，保证这条 const/guard + queued root aliased forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_forward_await.ll：本轮继续把 queued-root-chain helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let queued = queued_tasks[0]; let queued_ready = forward(queued); let second = await queued_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经两层 immutable alias chain、再投影出局部 task handle 并经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/62_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_forward_await.ql：本轮再把上述 queued-root-chain-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(65)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root、let queued = queued_tasks[0]、let queued_ready = forward(queued) 与 await queued_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 120，保证这条 const/guard + queued root chain forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_inline_forward_await.ll：本轮继续把 queued-root-aliased projected helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queued_tasks = queue_root; let second = await forward(queued_tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经一层 immutable alias、再直接投影并经 inline helper-returned await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/63_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_inline_forward_await.ql：本轮再把上述 queued-root-aliased-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(66)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queued_tasks = queue_root 与 await forward(queued_tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 122，保证这条 const/guard + queued root aliased inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_inline_forward_await.ll：本轮继续把 queued-root-chain projected helper-submit 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let queue_root = env.bundle.tasks; let queue_alias_root = queue_root; let queued_tasks = queue_alias_root; let second = await forward(queued_tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经两层 immutable alias chain、再直接投影并经 inline helper-returned await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/64_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_inline_forward_await.ql：本轮再把上述 queued-root-chain-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(67)] }, tail: tail_tasks[1] }、let queue_root = env.bundle.tasks、let queue_alias_root = queue_root、let queued_tasks = queue_alias_root 与 await forward(queued_tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 124，保证这条 const/guard + queued root chain inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_await.ll：本轮继续把 nested aggregate projected helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let bundle_tasks = env.bundle.tasks; let bundled = bundle_tasks[0]; let bundle_ready = forward(bundled); let second = await bundle_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 投影出局部 task handle、再经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/65_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_await.ql：本轮再把上述 bundle-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(68)] }, tail: tail_tasks[1] }、let bundle_tasks = env.bundle.tasks、let bundled = bundle_tasks[0]、let bundle_ready = forward(bundled) 与 await bundle_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 126，保证这条 const/guard + bundle forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_await.ll：本轮继续把 nested aggregate aliased projected helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let bundle_root = env.bundle.tasks; let bundle_tasks = bundle_root; let bundled = bundle_tasks[0]; let bundle_ready = forward(bundled); let second = await bundle_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经一层 immutable alias、再投影出局部 task handle 并经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/66_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_await.ql：本轮再把上述 bundle-aliased-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(69)] }, tail: tail_tasks[1] }、let bundle_root = env.bundle.tasks、let bundle_tasks = bundle_root、let bundled = bundle_tasks[0]、let bundle_ready = forward(bundled) 与 await bundle_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 128，保证这条 const/guard + bundle aliased forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_await.ll：本轮继续把 nested aggregate chain-projected helper-returned local path 的匹配 helper-await public surface 单独锁住。当前 async fn main 下的 let bundle_root = env.bundle.tasks; let bundle_alias_root = bundle_root; let bundle_tasks = bundle_alias_root; let bundled = bundle_tasks[0]; let bundle_ready = forward(bundled); let second = await bundle_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经两层 immutable alias chain、再投影出局部 task handle 并经 helper-returned local 过渡后 await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/67_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_await.ql：本轮再把上述 bundle-chain-forwarded-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(70)] }, tail: tail_tasks[1] }、let bundle_root = env.bundle.tasks、let bundle_alias_root = bundle_root、let bundle_tasks = bundle_alias_root、let bundled = bundle_tasks[0]、let bundle_ready = forward(bundled) 与 await bundle_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 130，保证这条 const/guard + bundle chain forwarded before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_inline_forward_await.ll：本轮继续把 nested aggregate aliased projected inline helper-await public surface 单独锁住。当前 async fn main 下的 let bundle_root = env.bundle.tasks; let bundle_tasks = bundle_root; let second = await forward(bundle_tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经一层 immutable alias、再直接投影并经 inline helper-returned await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/68_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_inline_forward_await.ql：本轮再把上述 bundle-aliased-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(71)] }, tail: tail_tasks[1] }、let bundle_root = env.bundle.tasks、let bundle_tasks = bundle_root 与 await forward(bundle_tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 132，保证这条 const/guard + bundle aliased inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_inline_forward_await.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_inline_forward_await.ll：本轮继续把 nested aggregate chain-projected inline helper-await public surface 单独锁住。当前 async fn main 下的 let bundle_root = env.bundle.tasks; let bundle_alias_root = bundle_root; let bundle_tasks = bundle_alias_root; let second = await forward(bundle_tasks[0]) 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经两层 immutable alias chain、再直接投影并经 inline helper-returned await 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/69_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_inline_forward_await.ql：本轮再把上述 bundle-chain-inline-forward-before-await guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(72)] }, tail: tail_tasks[1] }、let bundle_root = env.bundle.tasks、let bundle_alias_root = bundle_root、let bundle_tasks = bundle_alias_root 与 await forward(bundle_tasks[0]) / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 134，保证这条 const/guard + bundle chain inline forward before await + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_spawn.ll：本轮继续把 nested aggregate projected helper-returned local path 的匹配 helper-spawn public surface 单独锁住。当前 async fn main 下的 let bundle_tasks = env.bundle.tasks; let bundled = bundle_tasks[0]; let bundle_ready = forward(bundled); let running = spawn bundle_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 投影出局部 task handle、再经 helper-returned local 过渡后 spawn 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/70_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_spawn.ql：本轮再把上述 bundle-forwarded-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(73)] }, tail: tail_tasks[1] }、let bundle_tasks = env.bundle.tasks、let bundled = bundle_tasks[0]、let bundle_ready = forward(bundled) 与 spawn bundle_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 136，保证这条 const/guard + bundle forwarded before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_spawn.ll：本轮继续把 nested aggregate aliased projected helper-returned local path 的匹配 helper-spawn public surface 单独锁住。当前 async fn main 下的 let bundle_root = env.bundle.tasks; let bundle_tasks = bundle_root; let bundled = bundle_tasks[0]; let bundle_ready = forward(bundled); let running = spawn bundle_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经一层 immutable alias、再投影出局部 task handle 并经 helper-returned local 过渡后 spawn 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/71_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_spawn.ql：本轮再把上述 bundle-aliased-forwarded-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(74)] }, tail: tail_tasks[1] }、let bundle_root = env.bundle.tasks、let bundle_tasks = bundle_root、let bundled = bundle_tasks[0]、let bundle_ready = forward(bundled) 与 spawn bundle_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 138，保证这条 const/guard + bundle aliased forwarded before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-borrowck/tests/ownership.rs + crates/ql-codegen-llvm/src/lib.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_spawn.ql、tests/codegen/pass/async_program_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_spawn.ll：本轮继续把 nested aggregate chain-projected helper-returned local path 的匹配 helper-spawn public surface 单独锁住。当前 async fn main 下的 let bundle_root = env.bundle.tasks; let bundle_alias_root = bundle_root; let bundle_tasks = bundle_alias_root; let bundled = bundle_tasks[0]; let bundle_ready = forward(bundled); let running = spawn bundle_ready 现已进入 borrowck / llvm-ir / obj / exe / real-run 的定向矩阵，确认从 nested fixed-array aggregate root 先经两层 immutable alias chain、再投影出局部 task handle 并经 helper-returned local 过渡后 spawn 的路径现在也已成为当前 executable subset 的显式 public contract
crates/ql-cli/tests/executable_examples.rs + ramdon_tests/async_program_surface_examples/72_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_spawn.ql：本轮再把上述 bundle-chain-forwarded-before-spawn guarded const-backed helper path 提升到真实运行样例层。新样例单独锁住 let tail_tasks = pending.tasks、let forwarded = forward(alias[alias_slots[row]])、let running_task = forwarded、let env = Envelope { bundle: Bundle { tasks: [running_task, worker(75)] }, tail: tail_tasks[1] }、let bundle_root = env.bundle.tasks、let bundle_alias_root = bundle_root、let bundle_tasks = bundle_alias_root、let bundled = bundle_tasks[0]、let bundle_ready = forward(bundled) 与 spawn bundle_ready / await env.bundle.tasks[1] / await env.tail 的组合，在真实 toolchain 下锁定退出码 140，保证这条 const/guard + bundle chain forwarded before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + helper task-handle + sibling array element + nested fixed-array executable subset 已成为 committed public surface
crates/ql-codegen-llvm/src/lib.rs / crates/ql-driver/src/build.rs / crates/ql-cli/tests/codegen.rs + fixtures/codegen/pass/async_program_main_composed_dynamic_task_handle_reinit.ql、async_program_main_alias_sourced_composed_dynamic_task_handle_reinit.ql：本轮继续把 stable-dynamic path 的递归组合 program path 补齐到 llvm-ir / obj / exe。当前 await tasks[slots[row]]; tasks[slots[row]] = ...; await tasks[slots[row]] 以及再经一层 immutable alias 的 await tasks[alias[row]]; tasks[slots[row]] = ...; await tasks[alias[row]] 都已有定向 codegen / driver / CLI 回归与 LLVM IR snapshot，说明 composed stable path 及其 alias-sourced 变体不再只停留在 staticlib / executable 的隐式共享 lowering，而已成为当前 async program subset 的显式 public contract
这次实现层没有新增 ABI 或 lowering 分支；新回归证明的是 program-mode async body 已经复用既有 fixed-shape aggregate/task-handle lowering、projection write/reinit lowering、fixed-array literal-index branch-join reinit lowering，以及 direct-local task-handle consume/reinit lowering，只是此前缺少显式 coverage

P7.4 Task 4（已完成评估）：for await iterable surface 扩展边界

docs/plans/2026-03-29-phase-7-p7.2-runtime-and-interop.md：延后评估区已补充对比矩阵，确认当前 fixed-array for await lowering 直接依赖 concrete [N x T] layout 与 array_len metadata，而不是通用 iterator ABI 的别名
docs/plans/phase-7-concurrency-and-rust-interop.md / docs/roadmap/development-plan.md：已同步结论，明确 qlrt_async_iter_next 继续保留 capability/ABI placeholder 语义，不在本轮冻结 item release 协议
当前判断：dynamic array for await 继续 deferred；如果后续要扩面，优先单独设计不新增 runtime hook 的 Slice[T] / span-like fixed-shape view，并继续由 compiler 侧 index/load lowering 驱动

P7.4 Task 5（已完成）：Windows toolchain UX 收口

crates/ql-driver/src/toolchain.rs：Windows 下的 clang / archiver discover 现在除了 PATH 和显式 QLANG_CLANG / QLANG_AR 之外，还会 best-effort 探测常见 LLVM 安装位置（Scoop、%LOCALAPPDATA%\\Programs\\LLVM\\bin、%ProgramFiles%\\LLVM\\bin、%ProgramFiles(x86)%\\LLVM\\bin）
同一文件的 ToolchainError::NotFound hint 现在会给出具体候选路径，并继续提示 QLANG_AR_STYLE=lib|ar 的 wrapper 风格固定方式
crates/ql-cli/tests/ffi.rs：FFI 集成测试现已复用 ql-driver 的 toolchain discover 结果，不再单独只按 PATH / 环境变量决定是否跳过测试
当前边界仍保持保守：这是一条 best-effort LLVM 安装探测与 hint 收口，不代表已经实现完整 linker family discovery 或任意系统工具链枚举

下一步建议（待执行）：

P7.4 Task 3：继续放宽更多 await / spawn payload 路径（当前已额外锁定 executable 下 tuple / fixed-array / nested aggregate task-handle payload regression matrix）
若后续重新打开 for await iterable surface，只建议从不新增 runtime hook 的 Slice[T] / span-like fixed-shape view 设计切入；dynamic array 与通用 iterator 协议继续保持 deferred

详细计划见开发计划的 P7.4 小节。

P7.2 Task 1（已完成）：runtime hook ABI 合同细化

ql-runtime/src/lib.rs 补充完整的 hook 生命周期规约注释：enum-level overview 展示两组生命周期（frame/task creation group、spawn/await/release group），每条 variant 补充明确的 caller/callee 约定，TaskAwait 明确"backend load assumption"
ql-runtime/tests/executor.rs 新增三项生命周期单测：hook_lifecycle_create_await_result_load_release_abi_contract、hook_lifecycle_full_llvm_declaration_sequence_is_stable、async_iter_next_abi_contract_is_stable（共 14 项单测全通过）
ql-codegen-llvm/src/lib.rs 的 await lowering load 位置补充 INVARIANT 注释，显式引用 RuntimeHook::TaskAwait 合同文档

P7.2 Task 2（已完成）：Rust interop 双向工作流矩阵扩展

examples/ffi-rust/ql/callback_add.ql 新增 q_host_multiply import 与 q_scale export，实现两条独立的双向 FFI 路径
examples/ffi-rust/host/src/main.rs 提供两个 Rust 回调（q_host_add、q_host_multiply），调用两个 Qlang 导出（q_add_two、q_scale），两条路径均验证结果为 42
crates/ql-cli/tests/ffi.rs 的 ffi_rust_example_cargo_host_runs 扩展断言 q_scale(6, 7) = 42

边界约定（保持不变）：

must-return 的字面量常量 if/while/match 收口已到位；若需扩到一般常量传播或 branch pruning，应单独设计
loop-control 查询若需真正暴露到 editor 协议面，应延续当前 read-only bridge 路线
Task[...] 动态数组当前已打开三层保守子集：generic dynamic write/reinit、sibling-safe dynamic consume，以及 same immutable stable index path precise consume/reinit；另外 same-file const item 若能保守折回 literal/projection path，也已可命中对应的 definite move / precise reinit 结果；更广义的 arbitrary dynamic specific-element lifecycle 仍需继续评估

详细任务分解见 P7.2 Runtime 合同扩展与 Rust 互操作计划。

阶段状态表

阶段	状态	结论
P1	已完成	前端最小闭环已经稳定，后续前端修改应服务语义与中后端
P2	已完成基础阶段	语义地基、统一诊断、最小查询/LSP 已建立
P3	已完成基础阶段	MIR、ownership facts、cleanup-aware 分析与 closure groundwork 已建立
P4	已完成基础阶段	LLVM backend、artifact pipeline、extern C direct-call foundation 与 codegen harness 已建立
P5	已完成基础阶段	最小 C ABI 互操作、头文件生成、sidecar header 与真实 C 宿主集成已建立
P6	已完成基础阶段	same-file query / rename / completion / semantic-token / LSP parity 已系统收口
P7	进行中（P7.4）	已形成保守 async library/staticlib/dylib 闭环，并开放 `async fn main`（含 fixed-array `for await`）的 executable 程序入口子集

对后续开发的直接建议

P1-P7 之后，不应再回到“大而化之地继续堆功能”的工作方式。更合理的推进方向是：

在 P3 上继续补一般化 ownership / borrow / drop，而不是回头重做 MIR
在 P4/P5 上继续补 lowering、ABI 与 runtime，而不是推翻 driver/codegen/ffi 边界
在 P6 之上继续补 cross-file/project-indexed editor semantics，而不是重写 ql-analysis / QueryIndex
所有新增能力都要沿着现有 crate 边界、失败模型和测试矩阵扩展

这才是当前仓库最重要的阶段性成果：不是某个单点功能，而是已经有了一条后续不需要大规模返工的主干路径。

P1-P7 阶段总览 ​

总体结论 ​

P1: 前端最小闭环 ​

阶段目标 ​

切片进度 ​

P1.1 Workspace 与基础前端骨架 ​

P1.2 基础声明、类型与表达式 ​

P1.3 控制流、模式匹配与 formatter 稳定化 ​

P1.4 顶层声明补全与错误恢复增强 ​

P1.5 为 HIR lowering 预留前端边界 ​

已交付能力 ​

关键 crate ​

当前边界 ​

P2: 语义分析与类型检查地基 ​

阶段目标 ​

切片进度 ​

P2.1 HIR 与统一诊断边界 ​

P2.2 名称解析与作用域图 ​

P2.3 First-pass typing ​

P2.4 Duplicate / semantic diagnostics 硬化 ​

P2.5 Position-based query 与最小 LSP ​

已交付能力 ​

关键 crate ​

当前边界 ​

P3: MIR 与所有权分析地基 ​

阶段目标 ​

切片进度 ​

P3.1 Structural MIR Foundation ​

P3.2 Ownership Facts 与显式 move self ​

P3.3 Cleanup-aware ownership ​

P3.3b Move closure capture ownership ​

P3.3c Explicit MIR closure capture facts ​

P3.3d Closure escape groundwork ​

已交付能力 ​

关键 crate ​

当前边界 ​

P4: LLVM 后端与原生产物地基 ​

阶段目标 ​

切片进度 ​

P4.1 Backend foundation ​

P4.2 Object emission ​

P4.3 Executable emission ​

P4.4 Static library emission ​

P4.4b Dynamic library emission ​

P4.5 Extern C direct-call foundation ​

P4.6 Codegen golden harness 与失败模型 ​

已交付能力 ​

关键 crate ​

当前边界 ​

P5: C FFI 与宿主互操作地基 ​

阶段目标 ​

切片进度 ​

P5.1 Top-level extern "c" definition export ​

P5.2 Dynamic library emission ​

P5.3 Minimal C header generation ​

P5.4 Import / both surface projection ​

P5.5 Build-side sidecar header ​

P5.6 Real C-host integration harness ​

已交付能力 ​

关键 crate ​

当前边界 ​

P6: LSP 与编辑器语义收口 ​

阶段目标 ​

切片进度 ​

P6.1 Query truth surface 加固 ​

P6.2 Same-file rename 收口 ​

P6.3 Completion 收口 ​

P6.4 Semantic tokens 与桥接一致性 ​

P6.5 Editor-facing aggregate hardening ​

已交付能力 ​

关键 crate ​

当前边界 ​

P7: 并发、异步与 Rust 互操作（进行中） ​

当前范围 ​

本轮已完成 ​

下一步（P7.3 / P7.4 方向） ​

阶段状态表 ​

对后续开发的直接建议 ​

P1-P7 阶段总览

总体结论

P1: 前端最小闭环

阶段目标

切片进度

P1.1 Workspace 与基础前端骨架

P1.2 基础声明、类型与表达式

P1.3 控制流、模式匹配与 formatter 稳定化

P1.4 顶层声明补全与错误恢复增强

P1.5 为 HIR lowering 预留前端边界

已交付能力

关键 crate

当前边界

P2: 语义分析与类型检查地基

阶段目标

切片进度

P2.1 HIR 与统一诊断边界

P2.2 名称解析与作用域图

P2.3 First-pass typing

P2.4 Duplicate / semantic diagnostics 硬化

P2.5 Position-based query 与最小 LSP

已交付能力

关键 crate

当前边界

P3: MIR 与所有权分析地基

阶段目标

切片进度

P3.1 Structural MIR Foundation

P3.2 Ownership Facts 与显式 `move self`

P3.3 Cleanup-aware ownership

P3.3b Move closure capture ownership

P3.3c Explicit MIR closure capture facts

P3.3d Closure escape groundwork

已交付能力

关键 crate

当前边界

P4: LLVM 后端与原生产物地基

阶段目标

切片进度

P4.1 Backend foundation

P4.2 Object emission

P4.3 Executable emission

P4.4 Static library emission

P4.4b Dynamic library emission

P4.5 Extern C direct-call foundation

P4.6 Codegen golden harness 与失败模型

已交付能力

关键 crate

当前边界

P5: C FFI 与宿主互操作地基

阶段目标

切片进度

P5.1 Top-level `extern "c"` definition export

P5.2 Dynamic library emission

P5.3 Minimal C header generation

P5.4 Import / both surface projection

P5.5 Build-side sidecar header

P5.6 Real C-host integration harness

已交付能力

关键 crate

当前边界

P6: LSP 与编辑器语义收口

阶段目标

切片进度

P6.1 Query truth surface 加固

P6.2 Same-file rename 收口

P6.3 Completion 收口

P6.4 Semantic tokens 与桥接一致性

P6.5 Editor-facing aggregate hardening

已交付能力

关键 crate

当前边界

P7: 并发、异步与 Rust 互操作（进行中）

当前范围

本轮已完成

下一步（P7.3 / P7.4 方向）

阶段状态表

对后续开发的直接建议