Phase 7 并发、异步与 Rust 互操作

说明：本文保留了阶段推进时的大量样例路径记录。文中出现的 ramdon_tests/... 路径指向 crates/ql-cli/tests/executable_examples.rs 使用的本地忽略 smoke 目录，不是当前 checkout 自带的已提交样例目录。

目标

在不破坏 P1-P6 边界的前提下，把 async fn、await、spawn 从“语法存在”推进到“可分析、可诊断、可逐步降级”
给 runtime、executor、FFI 互操作建立清晰抽象，避免后续返工
保持测试驱动，先锁语义与失败模型，再扩执行能力

当前基础

前端已经有 async / await / spawn 语法节点
MIR 已有 for await 与相关结构化表示
LLVM backend 已有保守 async library lowering 子集，但更广义 async/runtime 语义仍显式保守
C ABI 与 header 投影已经稳定，可作为 Rust 混编入口

当前进度（2026-04-01）

当前整体判断：前端语法/词法与 same-file LSP 基线已经成型，当前主线瓶颈不再是“还能不能解析更多语法”，而是“已有语法里哪些能力已经进入可分析、可编译、可产出 artifact 的稳定子集”。因此后续优先级应继续落在 runtime / lowering / build-surface 的语言能力扩展，而不是先转向外围工具链 UX。

已在 ql-typeck 落地 await / spawn 的 async 上下文约束：在非 async fn 内使用会给出显式诊断
已补充 crates/ql-typeck/tests/async_typing.rs，锁住 await / spawn 边界与 async 函数内允许路径
已在 ql-resolve 增加 async 上下文查询契约（expr_is_in_async_function / scope_is_in_async_function）
已在 ql-analysis 暴露 async_context_at，可查询 await / spawn / for await 在当前位置是否位于 async fn 内
已补充 crates/ql-analysis/tests/queries.rs 的 async 查询回归
已在 ql-lsp bridge 层增加只读 async_context_for_analysis 桥接（不扩展协议面）
已补充 crates/ql-lsp/tests/bridge.rs 的 async 桥接回归
已把 for await 纳入 ql-analysis / ql-lsp async 查询桥接回归，统一 async 运算符语义查询面（for await 当前锚定 await 关键字 span）
已把 ql-resolve / ql-typeck / ql-analysis / ql-lsp 的 async 回归扩展到 trait / impl / extend 方法，锁住方法表面的 await / spawn / for await 语义上下文
已在 ql-typeck 增补 for await 上下文约束：非 async fn 内使用会给出显式诊断
已补充 crates/ql-typeck/tests/async_typing.rs 的 for await 边界回归
已在 ql-typeck 收紧 await / spawn 操作数约束：当前仅允许直接作用于 call expression，非调用操作数会给出显式诊断
已补充 crates/ql-typeck/tests/async_typing.rs 的非调用操作数回归（await value / spawn value）
已在 ql-typeck 继续收紧 await / spawn 的调用目标约束：当前不仅要求 operand 是 call expression，还要求被调用目标来自 async fn；sync function、sync method 与普通 closure/callable 值调用都会给出显式诊断
已补充 crates/ql-typeck/tests/async_typing.rs 的 async-call-target 回归，覆盖 sync function / async function / method / closure callable 这几类路径
已把 closure 视为独立 async 边界：closure body 当前不会继承外层 async fn 上下文，await / spawn / for await 会继续走非 async 诊断路径
已在 ql-typeck 修正 closure block 的显式 return 推断：当 closure 存在期望 callable 返回类型时，显式 return 会对齐 callable 签名；内层 nested closure 的 return 不会抬升外层 closure 返回类型
已在 ql-typeck 增补保守的 all-path return 分析：函数与 closure body 会拒绝“部分路径 return、部分路径 fallthrough”的情形；当前已覆盖 if 与最小穷尽性 match（_、Bool true/false、enum 全 variant）；带 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 ... } 与 closure 中同构写法现在会被接受；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 现在可查询当前位置是否位于 loop body；impl / extend / trait 方法和 closure loop-boundary 也有回归覆盖
已在 ql-driver / ql-cli 补充 async backend 边界回归：BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable 下的当前 async fn main 子集、staticlib 和最小 async dylib 子集已不再被统一拒绝；其余未开放 async surface 仍会在 build/codegen 阶段稳定返回结构化诊断
已在 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 行为
已开放 BuildEmit::LlvmIr / BuildEmit::Executable 下的 async fn main 最小程序入口生命周期：backend host @main wrapper 驱动 task_create -> executor_spawn -> task_await -> result_load -> task_result_release -> trunc/ret，并在 driver + CLI 黑盒层锁定
已锁定 BuildEmit::Executable 下的 nested task-handle payload 组合闭环：async fn main 中的 let next = await outer(); await next 现在在 codegen / driver / CLI 三层都有专项回归，说明 executable program-entry 已可稳定承载至少一条非直接 await 的 task-handle 续接路径
已补齐 BuildEmit::Executable 下的 aggregate task-handle payload regression matrix：tuple、fixed-array 与 nested aggregate payload（例如 await pair[0]、await tasks[1]、await pending[0].task）现在也已在 codegen / driver / CLI 三层有专项回归，证明 program-mode async body 继续复用既有 fixed-shape aggregate lowering，而不是只支持单一路径的 nested task handle
已锁定 BuildEmit::Executable 下的 direct task-handle parity 路径：当 direct async call 先绑定到本地（例如 let task = worker(1)、let other = worker(2)）再通过 await task 读取结果时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 direct-local task-handle lowering，而不是只覆盖 helper-return / helper-argument / aggregate-carried task-handle 路径
已锁定 BuildEmit::Executable 下的 bound task-handle spawn parity 路径：当 direct async call 先绑定到本地（例如 let task = worker(1)）再通过 let running = spawn task; await running 提交和等待结果时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 direct-local task-handle submit lowering，而不是只覆盖 helper-return、helper-argument 或 projection-sensitive spawn 路径
已锁定 BuildEmit::Executable 下的 helper task-handle parity 路径：await schedule()、let task = schedule(); await task、let task = spawn schedule(); await task、let forwarded = forward(task); await forwarded 与 let running = spawn forward(task); await running 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 继续复用既有 sync-helper task-handle lowering，而不是只在 library-mode 子集里成立
已锁定 BuildEmit::Executable 下的 local-return helper task-handle parity 路径：当 helper 先把 async call 绑定到本地再 return task（例如 fn schedule() -> Task[Int] { let task = worker(); return task } 与对应的 zero-sized Task[Wrap] 版本）时，await schedule() 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 local-return helper task-handle lowering，而不是只覆盖 direct-return helper 路径
已锁定 BuildEmit::Executable 下的 zero-sized helper task-handle parity 路径：当 helper 流动的句柄是 Task[Wrap] 且 Wrap 仅含 zero-sized fixed-array 字段时，await schedule()、bound helper handle、spawn schedule()、forwarded helper handle 与 spawn forward(task) 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 zero-sized loadable result / helper task-handle lowering
已锁定 BuildEmit::Executable 下的非零尺寸 aggregate-result parity 路径：当 async body 直接返回 tuple / fixed-array / struct（例如 (Bool, Int)、[Int; 3]、Pair { left: Int, right: Int }）并在 async fn main 中通过 direct await 读取结果时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 loadable aggregate-result lowering，而不是只覆盖 scalar、zero-sized aggregate 或 task-handle/result-carried-task 路径
已锁定 BuildEmit::Executable 下的 spawned 非零尺寸 aggregate-result parity 路径：当 tuple / fixed-array / struct 这类 loadable aggregate result 经由 let task = spawn ...; await task 读取时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 task-handle-aware spawn 与 loadable aggregate-result lowering，而不是只覆盖 scalar 或 zero-sized aggregate 的 spawned 路径
已锁定 BuildEmit::Executable 下的递归 aggregate-result parity 路径：当 async body 直接返回 nested loadable aggregate（例如 (Pair, [Int; 2])）并在 async fn main 中通过 direct await 读取结果时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 recursive loadable aggregate-result lowering，而不是只覆盖一层 tuple / fixed-array / struct 结果布局
已锁定 BuildEmit::Executable 下的 spawned 递归 aggregate-result parity 路径：当 nested loadable aggregate（例如 (Pair, [Int; 2])）经由 let task = spawn worker(); let value = await task 读取结果时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 task-handle-aware spawn 与 recursive loadable aggregate-result lowering，而不是只覆盖 direct await 的递归结果路径
已锁定 BuildEmit::Executable 下的 zero-sized aggregate-result parity 路径：当 async body 直接返回 [Int; 0] 或仅含 zero-sized fixed-array 字段的 Wrap，并在 async fn main 中通过 direct await 或 let task = spawn worker(); await task 读取结果时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 zero-sized loadable aggregate-result lowering，而不是只覆盖 task-handle/result-carried-task 路径
已锁定 BuildEmit::Executable 下的 aggregate-parameter parity 路径：当 async body 接收 recursive aggregate 参数（例如 Pair 与 [Int; 2]）或 zero-sized aggregate 参数（例如 [Int; 0]、Wrap { values: [Int; 0] } 与 [[Int; 0]; 1]）并在 async fn main 中通过 direct await 调用时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 async frame 参数物化与 aggregate-parameter lowering，而不是只在 library-mode 子集里成立
已锁定 BuildEmit::Executable 下的 spawned 递归 aggregate-parameter parity 路径：当 async body 接收 nested fixed-shape aggregate 参数（例如 spawn worker(Pair { left: 1, right: 2 }, [3, 4])）并在 async fn main 中通过 let task = spawn ...; await task 触发调用时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有带参 async frame 物化、task-handle-aware spawn 与 aggregate-parameter lowering，而不是只覆盖 direct await 的 aggregate-parameter 路径
已锁定 BuildEmit::Executable 下的 spawned zero-sized aggregate-parameter parity 路径：当 async body 接收 zero-sized fixed-shape aggregate 参数（例如 spawn worker([], Wrap { values: [] }, [[]])）并在 async fn main 中通过 let task = spawn ...; await task 触发调用时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 zero-sized async frame 物化、task-handle-aware spawn 与 aggregate-parameter lowering，而不是只覆盖 direct await 或 non-zero-sized aggregate 参数路径
已锁定 BuildEmit::Executable 下的 zero-sized nested / struct aggregate task-handle parity 路径：当 async fn outer() -> Task[Wrap] 或 async fn outer() -> Pending { first: Task[Wrap], second: Task[Wrap] } 且 Wrap 仅含 zero-sized fixed-array 字段时，let next = await outer(); await next 与 let pending = await outer(); await pending.first; await pending.second 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 zero-sized nested task-result 与 aggregate-carried task-handle lowering
已锁定 BuildEmit::Executable 下的 projected task-handle await parity 路径：当局部 tuple / fixed-array / struct-field projection 的结果本身就是 Task[Int] 这类 non-zero-sized task handle 时，await tuple[0] / await tuple[1]、await array[0] / await array[1] 与 await pair.left / await pair.right 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 projection-sensitive await lowering，而不是只覆盖 aggregate-carried payload 或 zero-sized Task[Wrap] 路径
已锁定 BuildEmit::Executable 下的 projected task-handle spawn parity 路径：当局部 tuple / fixed-array / struct-field projection 的结果本身就是 Task[Int] 这类 non-zero-sized task handle 时，let running = spawn tuple[0]; await running、let running = spawn array[0]; await running 与 let running = spawn pair.left; await running 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 projection-sensitive spawn lowering，而不是只覆盖 aggregate-carried payload 或 zero-sized Task[Wrap] 路径
已锁定 BuildEmit::Executable 下的 projected task-handle direct reinit parity 路径：当局部 tuple / fixed-array / struct-field projection 的结果本身就是 Task[Int] 这类 non-zero-sized task handle 时，let first = await tuple[0]; tuple[0] = worker(7); await tuple[0]、let first = await array[0]; array[0] = worker(8); await array[0] 与 let first = await pair.left; pair.left = worker(9); await pair.left 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 projection write/reinit lowering，而不是只覆盖 zero-sized Task[Wrap] 路径
已锁定 BuildEmit::Executable 下的 projected task-handle conditional reinit parity 路径：当 fixed-array literal index projection 的结果本身就是 Task[Int] 这类 non-zero-sized task handle 时，if flag { let first = await tasks[0]; tasks[0] = worker(7) } await tasks[0] 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 fixed-array literal-index projection 的 branch-join reinit lowering，而不是只覆盖 zero-sized Task[Wrap] 路径
已锁定 BuildEmit::Executable 下的 zero-sized projected task-handle await parity 路径：当局部 tuple / fixed-array / struct-field projection 的结果本身就是 Task[Wrap] 且 Wrap 仅含 zero-sized fixed-array 字段时，await tuple[0] / await tuple[1]、await array[0] / await array[1] 与 await pair.left / await pair.right 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 projection-sensitive await lowering
已锁定 BuildEmit::Executable 下的 zero-sized projected task-handle spawn parity 路径：当局部 tuple / fixed-array / struct-field projection 的结果本身就是 Task[Wrap] 且 Wrap 仅含 zero-sized fixed-array 字段时，let running = spawn tuple[0]; await running、let running = spawn array[0]; await running 与 let running = spawn pair.left; await running 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 projection-sensitive spawn lowering
已锁定 BuildEmit::Executable 下的 zero-sized projected task-handle direct reinit parity 路径：当局部 tuple / fixed-array / struct-field projection 的结果本身就是 Task[Wrap] 且 Wrap 仅含 zero-sized fixed-array 字段时，let first = await tuple[0]; tuple[0] = worker(); await tuple[0]、let first = await array[0]; array[0] = worker(); await array[0] 与 let first = await pair.left; pair.left = worker(); await pair.left 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 projection write/reinit lowering
已锁定 BuildEmit::Executable 下的 zero-sized projected task-handle conditional reinit parity 路径：当 fixed-array literal index projection 的结果本身就是 Task[Wrap] 且 Wrap 仅含 zero-sized fixed-array 字段时，if flag { let first = await tasks[0]; tasks[0] = worker() } await tasks[0] 现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 fixed-array literal-index projection 的 branch-join reinit lowering
已锁定 BuildEmit::Executable 下的 direct-local branch spawned reinit parity 路径：当 direct-local Task[Int] 的结果是 regular-size scalar，且控制流采用 if flag { let running = spawn task; task = fresh_worker(); return await running } else { task = fresh_worker() } return await task 这类模式时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 direct-local task-handle consume 后重初始化 lowering，而不是只覆盖 zero-sized fixed-shape aggregate 结果路径
已锁定 BuildEmit::Executable 下的 zero-sized direct-local branch spawned reinit parity 路径：当 direct-local Task[Wrap] 的结果是 zero-sized fixed-shape aggregate，且控制流采用 if flag { let running = spawn task; task = fresh_worker(); return await running } else { task = fresh_worker() } return await task 这类模式时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 direct-local task-handle consume 后重初始化 lowering
已锁定 BuildEmit::Executable 下的 zero-sized direct-local reverse-branch spawned reinit parity 路径：当 direct-local Task[Wrap] 的结果是 zero-sized fixed-shape aggregate，且控制流采用 if flag { task = fresh_worker() } else { let running = spawn task; task = fresh_worker(); return await running } return await task 这类模式时，program-mode 现在也已有 codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 reverse-branch direct-local task-handle consume 后重初始化 lowering
已锁定 BuildEmit::Executable 下的 conditional async-call spawn parity 路径：当 async fn choose(flag: Bool) -> Int 在一条分支里执行 let running = spawn worker(); return await running、另一条分支里直接 return await worker() 时，let first = await choose(true); let second = await choose_reverse(false) 这类正反分支组合现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 direct async-call submit 与 scalar result lowering，而不是只覆盖 zero-sized aggregate 结果路径
已锁定 BuildEmit::Executable 下的 zero-sized conditional async-call spawn parity 路径：当 async fn choose(flag: Bool) -> Wrap 在一条分支里执行 let running = spawn worker(); return await running、另一条分支里直接 return await worker()，且 Wrap 仅含 zero-sized fixed-array 字段时，let first = await choose(true); let second = await choose_reverse(false) 这类正反分支组合现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 direct async-call submit 与 zero-sized loadable result lowering，而不是只覆盖 helper/direct-local task-handle 路径
已锁定 BuildEmit::Executable 下的 conditional helper-task-handle spawn parity 路径：当 async fn choose(flag: Bool, task: Task[Int]) -> Int / choose_reverse(flag, task) 在条件分支里交替执行 spawn task 与 await task 时，await helper(true) 与 await helper_reverse(false) 这类 helper-argument 正反分支组合现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 helper 形参 task-handle submit/await lowering，而不是只覆盖 zero-sized 或 direct async-call 路径
已锁定 BuildEmit::Executable 下的 zero-sized conditional helper-task-handle spawn parity 路径：当 async fn choose(flag: Bool, task: Task[Wrap]) -> Wrap / choose_reverse(flag, task) 在条件分支里交替执行 spawn task 与 await task，且 Wrap 仅含 zero-sized fixed-array 字段时，await helper(true) 与 await helper_reverse(false) 这类 helper-argument 正反分支组合现在也已有 program-mode codegen / driver / CLI 定向回归，说明 executable async body 同样复用了既有 helper 形参 task-handle submit/await lowering，而不是只覆盖 direct async-call 或 direct-local task-handle 路径
已完成 for await iterable surface 的 docs-first 评估：当前 fixed-array lowering 直接依赖 concrete [N x T] layout 与 index-slot metadata，qlrt_async_iter_next 继续保留 placeholder ABI；dynamic array 与通用 iterator 路径继续 deferred，若后续扩面，优先考虑不新增 runtime hook 的 Slice[T] / span-like fixed-shape view 设计
已补充 dylib 路径上的 async backend 回归：当前在存在合法同步 extern "c" 导出时，最小 library-style async body 已可稳定通过；fixed-array iterable 的 for await 也已进入该受控子集，而非数组 iterable 与更广义 async surface 仍会给出稳定诊断
已补充 async + generic 并存场景回归，锁住 backend 同阶段多条 unsupported 诊断聚合行为
已补充 async + unsafe fn body 并存场景回归，锁住 backend 对函数签名级多条 unsupported 诊断的聚合与输出顺序
已在 ql-mir 增补 async operator lowering 回归：await / spawn 当前会作为显式 unary rvalue 保留，并消费前面物化的 call 结果；same-file import alias 的 async call 也会继续保留 Import callee，而不是退化成 opaque/unresolved operand
已在 crates/ql-cli/tests/ffi.rs 增补 Rust host 静态链接集成回归：Rust harness 现在既可以直接调用 Qlang staticlib 导出，也可以为 Qlang 的 extern "c" import 提供最小 callback，实现最保守的双向互操作基线
已在 crates/ql-cli/tests/ffi.rs 增补 Cargo-based Rust host smoke test：测试会临时生成最小 Cargo 工程，通过 build.rs 链接 Qlang staticlib，让 Rust 互操作从单文件 rustc 基线推进到更接近真实工作流的可复现路径
已提交 examples/ffi-rust：仓库内现在有真实的 Cargo host 示例，build.rs 会编译 sibling Qlang 源码并链接生成的 staticlib
已在 crates/ql-cli/tests/ffi.rs 增补 committed example 回归：会复制 examples/ffi-rust 后执行 cargo run --quiet，锁住示例本身的可运行性
已新增 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 的稳定符号名，并给出第一版 LLVM-facing contract string（当前统一走 ccc + opaque ptr 骨架）
已在 ql-analysis 暴露 runtime_requirements()：当前会按源码顺序枚举 async fn、spawn、await、for await 对应的 runtime 需求，为后续 driver/codegen 接线提供共享 truth surface
已补充 crates/ql-analysis/tests/queries.rs 的 runtime requirement 回归：覆盖 capability 顺序、精确 operator span，以及“仅声明无 body 的 async method 不计入 lowering 需求”的边界
已在 ql-cli 新增并扩展 ql runtime <file>：当前可直接输出该文件的 runtime requirements 与 dedupe 后的 runtime hook 计划，便于开发阶段检查 capability/hook contract 是否符合预期
ql-driver 已开始保守消费这份 runtime requirement surface：当前会把 async-function-bodies、task-spawn、task-await、async-iteration 映射成稳定的 build-time unsupported 诊断，并与 backend 同类 unsupported diagnostics 做去重合并
已在 ql-codegen-llvm 接入共享 runtime hook ABI contract：CodegenInput 当前可携带 dedupe 后的 RuntimeHookSignature 列表，后端会继续直接复用 ql-runtime 的 ABI contract 渲染 library-style runtime hook declarations；而在 BuildEmit::Executable program mode 下，当前同一套 contract 还会驱动最小 in-module runtime definitions / stub 的生成，而不是只停留在 declaration
已在 ql-codegen-llvm 增补最小 async frame scaffold：当前 body-bearing async fn 会拆成统一接收 ptr frame 的真实 body symbol（__async_body）、负责把 typed async 结果 heap-materialize 成 opaque result ptr 的 __async_entry thunk，以及公开 wrapper；parameterless wrapper 继续调用 qlrt_async_task_create(entry, null)，带参数 wrapper 会先通过 qlrt_async_frame_alloc(size, align) 构造最小 heap frame、写入参数，再调用 qlrt_async_task_create(entry, frame)，用于冻结最小 IR 结构
已在 ql-codegen-llvm / ql-driver / ql-cli 补上 library-mode async 边界回归：当前 spawn 既支持 statement-position fire-and-forget，也支持 value-position task-handle 绑定后继续 await；fixed-array iterable 的 for await 已在 library-mode async body 内通过，而 non-array iterable 与其余未开放 async surface 仍保持稳定 unsupported 诊断；await 也继续保留缺失 hook / 不支持结果布局等边界回归
已在 crates/ql-runtime / ql-cli / ql-codegen-llvm 增补 task-result transport 的第一条共享 ABI 合同：task-await 当前会同时暴露 qlrt_task_await(handle: ptr) -> ptr 与 qlrt_task_result_release(result: ptr) -> void；当前 backend/Program-mode runtime 把 fresh task handle 与 spawn-returned handle 统一到同一 awaitable opaque handle 形态，先冻结 result payload 的“返回”和“释放”边界，再延后 typed extraction / await lowering 的细节
已在 ql-codegen-llvm 增补 AsyncTaskResultLayout 内部抽象：当前 async 返回值已支持 Void、scalar builtin，以及递归可加载的 tuple / fixed array / 非泛型 struct 结果，并冻结“qlrt_task_await 返回的 opaque ptr 指向一块可直接 load 的 payload，取值后再调用 qlrt_task_result_release”这条 backend 内部假设；closure / 泛型 struct 等更广义聚合仍保持未开放
已在 ql-codegen-llvm 打开递归可加载 aggregate async frame 参数：带参数的 async fn wrapper 现在不再只接受 scalar/task-handle 参数，而是可把递归可加载的 tuple / fixed array / 非泛型 struct 参数写入 heap frame，并在 __async_body 中按同一布局回读
已在 ql-codegen-llvm 打开首个真实 await lowering：当前在 backend 内支持 Void / scalar builtin / Task[T] payload / recursively loadable aggregate async 结果，把 await 降成“读取 task handle -> qlrt_task_await -> load payload -> qlrt_task_result_release”；当前既支持直接 await <async-call>，也支持 let task = spawn ...; await task、let next = await outer(); await next 这类局部 task-handle 路径
已在 ql-codegen-llvm 打开最小 place projection lowering：当前嵌套 struct field read、constant tuple index read、array index read 已走统一投影链并进入 LLVM lowering；struct-field / constant tuple-index write、fixed-array literal index write，以及非 Task[...] 元素的 dynamic array assignment 也已接入同一条 lowering，而 Task[...] 动态数组元素赋值现也已进入保守 lowering 子集：generic dynamic tasks[index] = worker() 会走同一条 projection pointer lowering 但只保留 maybe-overlap 结果；same immutable stable index path（例如 index、slot.value，以及可折回 literal/projection path 的 same-file const item）则已可恢复 precise consume/reinit
已在 ql-codegen-llvm / ql-driver / ql-cli 打开 projected task-handle operand lowering：当 field/index projection 的结果类型本身就是 Task[T] 时，await pair[0]、spawn pair[0]、await tasks[0]、spawn tasks[0]、await pair.task、spawn pair.task 这类路径现在都可稳定通过 codegen 与 staticlib 构建；当前数组路径除 fixed-array literal index 外，borrowck 也已放开两层 conservative dynamic consume 子集：generic dynamic await pending.tasks[index] / spawn pending.tasks[index] 不再直接污染 sibling projection，而 same immutable stable index path（例如 index、slot.value）现也可精确识别为同一路径；本轮又把 same-file const item（例如 INDEX、SLOT.value）接进同一条 literal/projection lowering，避免 build surface 与 borrowck 精度再次分叉
generic dynamic task-handle array 的 user-facing build matrix 现也已显式锁定：tasks[index] = worker() 这条 generic dynamic assignment，以及 let running = spawn pending.tasks[index]; let second = await pending.fallback 这条 sibling-safe dynamic consume/spawn，当前都已有 staticlib async helper、program-mode async fn main()、driver build 与 CLI fixture 的对应回归，不再只依赖内部 codegen/driver 单测来证明可用性；本轮又把 aggregate field root 上的 projected-root 路径补进来，确认 pending.tasks[slot.value] 的 reinit 与 pending.tasks[INDEX] 的 const-backed literal reuse 也都进入了同一条用户可见回归矩阵
borrowck / driver / 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]]）时，不再因为中间还有一层 dynamic segment 就退回 generic maybe-overlap，而会继续沿用 stable-dynamic path 的 definite move / precise reinit 结果
同一条 composed stable dynamic source path 现也可继续穿过 immutable alias：let alias = slots; await tasks[alias[row]]; tasks[slots[row]] = worker(); await tasks[alias[row]] 这类跨源路径 consume/reinit，不再因为 alias 把 base place 换成了另一份 immutable binding 就退回 maybe-overlap，而会继续命中 stable-dynamic path 的 definite move / precise reinit 结果
borrowck 现也已补上最小 immutable const-backed literal normalization：当 dynamic index 来自 let index = 0、let slot = Slot { value: 0 }、const INDEX: Int = 0 或 const SLOT: Slot = Slot { value: 0 } 这类可保守折回 literal 的来源时，tasks[index] / tasks[slot.value] / tasks[INDEX] / tasks[SLOT.value] 都会和 tasks[0] 归并到同一 fixed-array literal path，因此 literal reuse 与 reinit/restore 的 ownership 结果不再额外退化成 generic dynamic overlap
borrowck 现也已补上 same immutable source alias normalization：当 dynamic index 来自 let alias = index 或 let slot = Slot { value: index } 这类不可变别名，且最终仍指向同一个稳定 source path 时，tasks[alias] / tasks[slot.value] 会和 tasks[index] 归并到同一 stable dynamic path，因此跨别名 reuse / reinit 的 ownership 结果不再额外退化成 generic dynamic overlap
borrowck / driver / 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] 不会再把 consume 记到 alias local 自身，而会继续命中 source root；因此 await alias; await task / await alias[index]; await tasks[index] 现在都会稳定报 source-root definite use-after-move，而 task = worker() / pending.tasks[index] = worker() 这类 source-local/source-path reinit 也会恢复后续 await alias / await alias[index] 的可用性
同一条 task-handle root alias canonicalization 现也已覆盖普通 alias read，而不再只作用于 task-handle consume site：let pair = (alias, worker())、let pair = (alias[index], worker()) 这类 aggregate repackage 现在不会再把已移动句柄偷偷重新包装成新的 aggregate-carried task handle，而会在 alias read 处继续报 source-root use-after-move；对应的 source-local/source-path reinit 后，alias-fed aggregate repackage 也会恢复通过
已在 ql-codegen-llvm 打开首个真实 spawn lowering 子集：当前在 backend 内支持把 task-handle operand 降成“读取 task handle -> qlrt_executor_spawn(ptr null, task) -> 返回 task handle”，覆盖 direct async call、局部绑定 handle 与 sync helper 返回 handle 这几条路径；statement-position fire-and-forget 只是显式丢弃返回句柄的特例
已在 ql-codegen-llvm 收紧 empty-array lowering 的 expected-context 合同：当前会把“返回槽 / 已知 direct temp use / 直调参数 / 已知 tuple-array-struct 聚合字面量”的具体 [T; N] 期望类型保守回传到 direct temp locals，因此 return []、take([])、([], 1)、Wrap { values: [] } 与 [[]] 这类已有 [T; N] 上下文的路径都可以稳定 lowering，而裸 [] 仍保持显式拒绝
已在 ql-codegen-llvm / ql-driver / ql-cli 锁住 zero-sized async parameter 合同：async fn worker(values: [Int; 0], wrap: Wrap { values: [Int; 0] }, nested: [[Int; 0]; 1]) 这类 zero-sized aggregate 参数现在也稳定走当前递归可加载 frame 模型，对应 wrapper/frame/await/staticlib 路径都已有回归覆盖
已在 ql-codegen-llvm / ql-driver / ql-cli 锁住 zero-sized async result 合同：[Int; 0] 与只包含 zero-sized fixed-array 字段的递归 aggregate 现在仍按 loadable async result 处理，async fn -> [Int; 0]、async fn -> Wrap { values: [Int; 0] }、let task = spawn worker(); await task、let task = worker(); let running = spawn task; await running 这类 direct/bound task-handle await，以及 fn schedule() -> Task[Wrap]、fn schedule() { let task = worker(); return task }、fn forward(task: Task[Wrap]) -> Task[Wrap]、let task = spawn schedule(); await task、let task = schedule(); let running = spawn task; await running、let task = worker(); let running = spawn forward(task); await running 这些 helper task-handle 路径都已有回归覆盖并通过 staticlib 构建
已在 ql-typeck / ql-borrowck / ql-codegen-llvm / ql-driver / ql-cli 锁住 nested task-handle payload 合同：async fn outer() -> Task[Int] { return worker() } 与 zero-sized async fn outer() -> Task[Wrap] { return worker() } 现在都允许 let next = await outer(); await next 这条 chained-await 路径，第一次 await 产出的 fresh task handle 会继续走同一套 consume / lowering / staticlib build 合同
已在 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()，再通过 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 aggregate result、projection-sensitive consume 与 projection await lowering，而不额外引入第二套 await-join 协议
已补上 helper branch-join consume/reinit 的零尺寸 Task[Wrap] 前端回归：if flag { forward(task) } else { task = fresh_worker() } 与 reverse-branch 版本现在都已在 ql-typeck / ql-borrowck 里锁住，并同步了 borrowck debug render 事实；ql-driver 现也把这条 helper 边界收紧成稳定的分析期失败合同，保证它不会误入 ql-codegen-llvm / ql-driver 的 staticlib 成功链路
已在 ql-driver 放开 public async build 子集：staticlib 现在允许已被 backend 支持的 async library body + scalar/task-handle/tuple/array/struct/void await + spawn task-handle 绑定/await 路径通过构建，并对 fixed-array iterable 打开 for await lowering；dylib 也已开放最小 library-style async body 子集，只要公开导出面仍收敛在同步 extern "c" C ABI，且 fixed-array iterable 的 for await 同样可通过；BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable 也已开放 async fn main 的最小程序入口生命周期与 fixed-array for await 子集，其中 executable 继续通过 program-mode 内联最小 runtime support 进入“可链接、可运行”的受控切片。更广义的 async program/bootstrap surface、dylib surface 与 async iteration 仍保持保守拒绝
已补充 ql-driver / ql-cli 的 mixed-surface 回归：当前 staticlib 的 async library subset 已被黑盒锁住可与 extern "c" export header sidecar 共存，保证异步内部 helper 不会污染公开 C header surface
已在 ql-resolve / ql-typeck 打开首个显式 task-handle 类型面：当前 Task[T] 会作为保留类型根被接受，并映射到内部 Task[...] 句柄类型；direct async fn call、spawned task、局部绑定 handle 与 sync helper 返回值现在都能统一落到这条句柄语义上
已在 ql-typeck 把 spawn 的消费模型对齐到 task-handle 语义：spawn task 与 spawn schedule()（其中 schedule() -> Task[T]）现在都可保守通过；非 task operand 会给出稳定诊断，而不是继续把 spawn 限死在“直接 async call”形态
已在 ql-typeck 移除 direct async call 的“必须立刻 await / spawn”限制：let task = worker(); await task、forward(worker())、return worker() 到 Task[T] helper 等路径现在都可保守通过；当 direct async call 最终被放进非 Task[T] 上下文时，会自然退化成普通类型不匹配（例如 Task[Int] vs Int），不再依赖单独的特判诊断
已在 ql-borrowck 扩展 task-handle 生命周期边界：direct-local Task[T] 当前会在 await / spawn、静态可判定的 helper Task[T] 形参传递、以及 direct-local return task 时被视为 consume，后续复用会给出稳定的 use-after-move / maybe-moved 诊断，而重赋值仍可把 local 恢复为可用状态；projected task-handle operand 当前也已纳入这条边界，并会把 await pair[0] / await tasks[0] / await pair.task 这类消费精确记到 projection path，而不是退化成整个 base local，因此 awaited aggregate payload 中的 sibling task-handle projection 也能稳定共存；dynamic fixed-array index task-handle consume 现也已进入分层 path-sensitive 子集：generic dynamic path 不再直接污染 sibling field / sibling task projection，而 same immutable stable index path（例如 index、slot.value）会进一步落到 stable-dynamic path，因此 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] 也可恢复通过；同一轮里，same-file const item 若能保守折回同一 literal/projection path，也会继承相同精度，因此 await tasks[INDEX]; await tasks[0] 与 await tasks[SLOT.value]; tasks[0] = worker(); await tasks[SLOT.value] 不再退化回 generic dynamic maybe-overlap；本轮又补上最小 equality-guard dominated-branch refinement，因此 if index == 0 { await tasks[index]; tasks[0] = worker() } await tasks[0] 与 if slot.value == 0 { await tasks[slot.value]; tasks[0] = worker() } await tasks[0] 现在也会回收到同一条 literal/projection path，而不再在 branch join 上保守停留为 maybe-moved；当前这条 guard-sensitive reinit 现已同时进入两类 async fn main 的 llvm-ir / obj / exe program build matrix：direct main 里的 projected slot.value == 0 路径，以及经由 internal async helper body 进入的 direct index == 0 路径；await pending.tasks[0] 这类跨具体元素读取仍只会给出 maybe-moved。当前这条边界也已显式覆盖 conditional cleanup 的 reinit/consume、helper-consume/reinit 与 reverse-branch helper-consume/reinit 这三类零尺寸 Task[Wrap] 回归
同一套 guard-sensitive 生命周期事实现也已进入 deferred cleanup 的 HIR evaluator：defer if index == 0 { forward(tasks[index]) } else { ... } 与 projected slot.value 版本现在会在 cleanup then-branch 内回收到 tasks[0]，并且会结合外层 index != 0 / slot.value != 0 路径携带的“排除具体元素”事实裁掉不可能分支，因此 tasks[0] = worker() 后的 deferred helper consume 不再误报 use-after-move；用户可见 build 面现已开放首个 cleanup lowering 子集：direct / call-backed defer、bool-guard 驱动的 call-backed if cleanup branch、bool/int scrutinee + literal/path/wildcard arms + optional bool guard 的 cleanup match branch，以及这些已开放 cleanup 子路径上的透明 ? wrapper。更广义的 cleanup control flow 与 closure / for / for await cleanup 仍继续保持 unsupported 合同
普通 Rvalue::Question 现已接入透明 lowering：return helper()?、match-wrapped helper()?、cleanup-adjacent return helper()? 与 cleanup-internal defer helper()? 都不再因为 question-mark 本身被 backend 拦截；当前 remaining blocker 已不再包含 ordinary / cleanup-internal question-mark path
2026-04-04 复核结论：cleanup lowering / codegen 仍是主线，但下一个真实 blocker 已从 cleanup-internal ? 前移到更广 cleanup control flow 本身，尤其是 closure / for / for await cleanup。继续补 payload 相邻变体更多是在收口 coverage，不是消除当前最明显的语言功能缺口
当前 stable-dynamic path 也已可递归组合到由稳定 dynamic source path 构成的 index 表达式：tasks[slots[row]] 这类路径若其 source path 本身仍由不可变局部/投影稳定组成，就会继续进入 definite move / precise reinit；更广义的 arbitrary dynamic overlap reasoning 仍保持未开放
当前同一条 stable-dynamic path 还可穿过一层 immutable place-like alias：若 let alias = slots 这类绑定仍只是重新指向同一条 place-like source path，那么 tasks[alias[row]] 会继续和 tasks[slots[row]] 落到同一条 stable-dynamic path；更广义的 arbitrary dynamic overlap reasoning 仍保持未开放
projected dynamic task-handle reinit 的 user-facing build matrix 现也已显式锁定：library-mode helper(flag, index) 与 program-mode async fn main() 下的 await tasks[slot.value]; tasks[slot.value] = worker(); await tasks[slot.value] 以及 branch-join if flag { ... } await tasks[slot.value] 路径，现在都已有 borrowck / codegen / driver / CLI 对应回归，不再只依赖“底层 lowering 共享所以应该能过”的隐式事实；本轮又补上 const SLOT: Slot = Slot { value: 0 } 与 const INDEX: Int = 0 的对应回归，并把同样的 projected-root 形态 pending.tasks[slot.value] / pending.tasks[INDEX] 一并纳入 driver + CLI 的定向覆盖，确认 aggregate field root 不会成为新的用户可见缺口
projected-root dynamic task-handle reinit 的 program-mode emit parity 现也已锁定：async fn main() -> Int { let first = await pending.tasks[slot.value]; pending.tasks[slot.value] = worker(first + 1); return await pending.tasks[slot.value] } 这条 aggregate field root 路径现在已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot，避免它只在 exe 或 shared lowering 的隐式路径里“顺带可用”而没有单独 contract
const-backed projected-root literal reuse 的 program-mode emit parity 现也已锁定：async fn main() -> Int { let first = await pending.tasks[INDEX]; pending.tasks[0] = worker(first + 3); let second = await pending.tasks[INDEX]; let tail = await pending.tasks[1]; return second + tail } 这条 same-file const item 驱动的 aggregate field root 路径现在也已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot，避免 pending.tasks[INDEX] 只在 borrowck 与 shared lowering 里“理论上可用”而缺少 public contract
projected-root alias-root canonicalization 的 program-mode emit parity 现也已锁定：async fn main() -> Int { let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = worker(first + 4); let second = await alias[slot.value]; let tail = await pending.tasks[1]; return second + tail } 这条 immutable alias 重新绑定 aggregate field root 的路径现在也已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot；backend 现会在 task-handle place lowering 时把这类 alias local 回溯到 source root/path，而不再读取早先 materialize 出来的 stale aggregate copy
const-backed projected-root alias-root canonicalization 的 program-mode emit parity 现也已锁定：async fn main() -> Int { let alias = pending.tasks; let first = await alias[INDEX]; pending.tasks[0] = worker(first + 2); let second = await alias[INDEX]; let tail = await pending.tasks[1]; return second + tail } 这条 immutable alias 与 same-file const item 组合出的 aggregate field root 路径现在也已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot，确认 alias-root canonicalization 与 const-backed literal normalization 在 program mode 下不会重新分叉
guard-refined projected-root alias-root canonicalization 的 program-mode emit parity 现也已锁定：async fn main() -> Int { 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]; let tail = await pending.tasks[1]; return second + tail } 这条 immutable alias 与 equality guard 组合出的 aggregate field root 路径现在也已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot，确认 alias-root canonicalization 与 dominated-branch literal refinement 在 program mode 下不会重新分叉
const-backed + guard-refined projected-root alias-root canonicalization 的 program-mode emit parity 现也已锁定：async fn main() -> Int { 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]; let tail = await pending.tasks[1]; return second + tail } 这条 immutable alias、same-file const item 与 equality guard 组合出的 aggregate field root 路径现在也已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot，确认这三条既有 canonicalization/refinement 能力在 program mode 下不会重新分叉
composed stable-dynamic path 的 program-mode emit parity 现也已锁定：async fn main() -> Int { let row = choose(); let slots = [row, row]; let first = await tasks[slots[row]]; tasks[slots[row]] = worker(first + 1); return await tasks[slots[row]] } 与再经一层 immutable alias 的 let alias = slots; await tasks[alias[row]]; tasks[slots[row]] = worker(first + 1); await tasks[alias[row]] 两条路径，现都已同时覆盖 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable，并补上独立 LLVM IR snapshot，避免 stable-dynamic path 的递归组合与 alias-sourced 变体只在 shared lowering 的隐式路径里“顺带可用”
上述两条 program 路径现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/10_async_main_guard_refined_projected_root.ql 会把 helper-based guard-refined direct path 与 direct projected-root reinit path 组合到同一条 async fn main，crates/ql-cli/tests/executable_examples.rs 现会在真实 toolchain 下构建并运行该样例，锁定退出码 49，把最新能力从“公开可构建子集”进一步收口成“公开可运行子集”
const-backed projected-root program path 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/11_async_main_const_backed_projected_root.ql 会单独锁住 await pending.tasks[INDEX]; pending.tasks[0] = ...; await pending.tasks[INDEX] 这条 same-file const item 驱动的 projected-root literal reuse，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 24，把这条能力同样收口到公开可运行子集
projected-root alias-root canonicalization 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/12_async_main_aliased_projected_root.ql 会单独锁住 let alias = pending.tasks; await alias[slot.value]; pending.tasks[slot.value] = ...; await alias[slot.value] 这条 source-root reinit 恢复 alias 可用性的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 17，把这条能力同样收口到公开可运行子集
const-backed projected-root alias-root canonicalization 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/13_async_main_aliased_const_backed_projected_root.ql 会单独锁住 let alias = pending.tasks; await alias[INDEX]; pending.tasks[0] = ...; await alias[INDEX] 这条 same-file const item 驱动的 alias-root projected-root 路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 17，把这条能力同样收口到公开可运行子集
guard-refined projected-root alias-root canonicalization 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/14_async_main_aliased_guard_refined_projected_root.ql 会单独锁住 let alias = pending.tasks; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } await alias[0] 这条 equality-guard + alias-root 组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 21，把这条能力同样收口到公开可运行子集
alias-fed tuple repackage after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/16_async_main_aliased_projected_root_tuple_repackage_reinit.ql 会单独锁住 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = ...; let pair = (alias[slot.value], worker(5)); await pair[0] 这条 alias-root projected task handle 先重初始化、再经 tuple aggregate 重新包装的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 31，把 aggregate repackage 这条更贴近真实用户写法的路径也收口到公开可运行子集
alias-fed struct repackage after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/17_async_main_aliased_projected_root_struct_repackage_reinit.ql 会单独锁住 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = ...; let bundle = Bundle { left: alias[slot.value], right: worker(6) }; await bundle.left 这条 alias-root projected task handle 先重初始化、再经 named struct aggregate 重新包装的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 32，把 aggregate repackage 再从 tuple 推进到更贴近业务对象封装的 struct 形态
alias-fed nested aggregate repackage after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/18_async_main_aliased_projected_root_nested_repackage_reinit.ql 会单独锁住 let alias = pending.tasks; let first = 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 这条 alias-root projected task handle 先重初始化、再经 nested aggregate 重新包装的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 33，把 aggregate repackage 再从单层对象推进到更贴近真实多层对象封装的 nested 形态
const-backed + guard-refined nested aggregate repackage after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/19_async_main_aliased_guard_refined_const_backed_nested_repackage_reinit.ql 会单独锁住 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 这条 const/guard/alias/nested aggregate 组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 36，把 nested aggregate repackage 进一步推进到更贴近真实复杂对象封装的组合形态
alias-fed nested aggregate repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/20_async_main_aliased_projected_root_nested_repackage_spawn.ql 会单独锁住 let alias = pending.tasks; let first = 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 这条 alias-root projected task handle 先重初始化、再经 nested aggregate 重新包装并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 34，把 nested aggregate repackage 再推进到更贴近真实任务提交流程的 spawn 形态
const-backed + guard-refined nested aggregate repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/21_async_main_aliased_guard_refined_const_backed_nested_repackage_spawn.ql 会单独锁住 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 这条 const/guard/alias/nested aggregate/spawn 组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 38，把 nested aggregate submit surface 进一步推进到更贴近真实复杂任务提交流程的组合形态
alias-fed fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/22_async_main_aliased_projected_root_array_repackage_spawn.ql 会单独锁住 let alias = pending.tasks; let first = await alias[slot.value]; pending.tasks[slot.value] = ...; let tasks = [alias[slot.value], worker(10)]; let running = spawn tasks[0] 这条 alias-root projected task handle 先重初始化、再经 fixed-array 重新包装并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 37，把 alias-root aggregate repackage 再补齐到 array 形态
const-backed + guard-refined fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/23_async_main_aliased_guard_refined_const_backed_array_repackage_spawn.ql 会单独锁住 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] 这条 const/guard/alias/fixed-array repackage/spawn 组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 40，把 array submit surface 进一步推进到更贴近真实复杂任务提交流程的组合形态
alias-fed nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/24_async_main_aliased_projected_root_nested_array_repackage_spawn.ql 会单独锁住 let alias = pending.tasks; let first = 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] 这条 alias-root projected task handle 先重初始化、再嵌入 nested fixed-array aggregate 并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 41，把 array submit surface 再推进到更贴近真实复杂对象封装的组合形态
const-backed + guard-refined nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/25_async_main_aliased_guard_refined_const_backed_nested_array_repackage_spawn.ql 会单独锁住 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] 这条 const/guard/alias/nested fixed-array repackage/spawn 组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 46，把 nested array submit surface 进一步推进到更贴近真实复杂任务提交流程的组合形态
composed-dynamic nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/26_async_main_composed_dynamic_nested_array_repackage_spawn.ql 会单独锁住 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] 这条 composed stable-dynamic path 先重初始化、再嵌入 nested fixed-array aggregate 并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 47，把 nested array submit surface 再推进到 stable-dynamic 组合形态
alias-sourced composed-dynamic nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/27_async_main_alias_sourced_composed_dynamic_nested_array_repackage_spawn.ql 会单独锁住 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] 这条 alias-sourced composed stable-dynamic path 先重初始化、再嵌入 nested fixed-array aggregate 并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 48，把 nested array submit surface 再推进到 alias-sourced stable-dynamic 组合形态
const-backed + guard-refined alias-sourced composed-dynamic nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/28_async_main_guarded_alias_sourced_composed_dynamic_nested_array_repackage_spawn.ql 会单独锁住 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]] = 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] 这条 const/guard + alias-sourced composed stable-dynamic path 先重初始化、再嵌入 nested fixed-array aggregate 并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 50，把 nested array submit surface 再推进到更完整的 stable-dynamic 组合形态
helper-forwarded nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/29_async_main_aliased_projected_root_forwarded_nested_array_repackage_spawn.ql 会单独锁住 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] 这条 helper-forwarded task handle 先重初始化、再嵌入 nested fixed-array aggregate 并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 52，把 helper task-handle surface 再推进到更贴近真实对象封装与提交流程的组合形态
const-backed + guard-refined helper-forwarded nested fixed-array repackage spawn after source-root reinit 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/30_async_main_aliased_guard_refined_const_backed_forwarded_nested_array_repackage_spawn.ql 会单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { 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] 这条 const/guard + helper-forwarded task handle 先重初始化、再嵌入 nested fixed-array aggregate 并提交的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 54，把 helper task-handle surface 再推进到更完整的 nested submit 组合形态
alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling task field 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/31_async_main_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn_with_tail_field.ql 会单独锁住 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 + 9); let env = Envelope { bundle: Bundle { tasks: [forward(alias[alias_slots[row]]), worker(24)] }, tail: pending.tail } 这条 alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling task field 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 59，把 helper task-handle surface 正式推进到 alias-sourced composed-dynamic 组合形态
const-backed + guard-refined alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling task field 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/32_async_main_guarded_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn_with_tail_field.ql 会单独锁住 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 } 这条 const/guard + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling task field 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 63，把 helper task-handle surface 再推进到更完整的 guarded alias-sourced composed-dynamic 组合形态
const-backed alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/33_async_main_const_backed_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql 会单独锁住 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] } 这条 same-file const-backed + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并恢复到 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 61，把 helper task-handle surface 正式推进回同数组兄弟元素组合形态
guarded const-backed alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/34_async_main_guarded_const_backed_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql 会单独锁住 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] } 这条 const/guard + same-file const-backed + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并恢复到 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 62，把 helper task-handle surface 再推进到更完整的 guarded 同数组兄弟元素组合形态
guarded const-backed double-root-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/35_async_main_guarded_const_backed_double_root_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql 会单独锁住 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] } 这条 const/guard + same-file const-backed + double-root alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 64，把 helper task-handle surface 继续推进到双根别名组合形态
guarded const-backed double-root-aliased double-source-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + double-root alias + double-source alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 66，把 helper task-handle surface 继续推进到双根双源别名组合形态
guarded const-backed double-root-aliased double-source-aliased row-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + row alias + double-root alias + double-source alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 68，把 helper task-handle surface 继续推进到双根双源加 row alias 的组合形态
guarded const-backed double-root-aliased double-source-aliased row-aliased slot-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + slot alias + row alias + double-root alias + double-source alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 72，把 helper task-handle surface 继续推进到双根双源加 row/slot alias 的组合形态
guarded const-backed triple-root-aliased double-source-aliased row-aliased slot-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + triple-root alias + slot alias + row alias + double-source alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 74，把 helper task-handle surface 继续推进到 triple-root + row/slot alias 的组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 76，把 helper task-handle surface 继续推进到 triple-root + triple-source + row/slot alias 的组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再嵌入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 78，把 helper task-handle surface 继续推进到 triple-root + triple-source + row/slot/tail alias 的组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：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 会单独锁住 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] } 这条 const/guard + same-file const-backed + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再经局部别名流入 nested fixed-array aggregate，并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 80，把 helper task-handle surface 继续推进到 forwarded-alias 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased queued-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/43_async_main_guarded_const_backed_triple_root_triple_source_tail_queued_spawn.ql 会单独锁住 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 这条 const/guard + same-file const-backed + queued alias before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再经局部别名和 nested fixed-array aggregate 重组，随后通过额外队列别名提交并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 82，把 helper task-handle surface 继续推进到 queued-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased queued-root-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/44_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_spawn.ql 会单独锁住 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 这条 const/guard + same-file const-backed + queued root alias before spawn + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再经局部别名和 nested fixed-array aggregate 重组，随后通过额外队列根别名提交并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 84，把 helper task-handle surface 继续推进到 queued-root-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased queued-root-aliased-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/45_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_spawn.ql 会单独锁住 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 这条 const/guard + same-file const-backed + queued root alias before spawn 再多一层 immutable alias + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再经局部别名和 nested fixed-array aggregate 重组，随后通过额外队列根别名链提交并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 86，把 helper task-handle surface 继续推进到 queued-root-aliased-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased queued-root-chain-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/46_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_spawn.ql 会单独锁住 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 这条 const/guard + same-file const-backed + queued root alias before spawn 再多一层 immutable alias chain + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再经局部别名和 nested fixed-array aggregate 重组，随后通过额外队列根别名链提交并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 88，把 helper task-handle surface 继续推进到 queued-root-chain-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased queued-local-aliased-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/47_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_alias_spawn.ql 会单独锁住 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 这条 const/guard + same-file const-backed + queued local alias before spawn 叠加在 queued-root alias chain 之上 + forwarded alias + tail alias + triple-source alias + triple-root alias + row/slot alias + alias-sourced composed stable-dynamic path 先经 helper 转发、再经局部别名和 nested fixed-array aggregate 重组，随后通过额外队列局部别名提交并继续保留 sibling array element 可用的 program path，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 90，把 helper task-handle surface 继续推进到 queued-local-aliased-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased forwarded-aliased queued-local-chain-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/48_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_chain_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-local-chain-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased double-forwarded queued-local-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/49_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-local-forwarded-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased inline-double-forwarded queued-local-before-spawn alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/50_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-local-inline-forward-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/51_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-inline-forward-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-slot-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/52_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-slot-inline-forward-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased tail-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/53_async_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 tail-inline-forward-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased tail-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/54_async_main_guarded_const_backed_triple_root_triple_source_tail_direct_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 tail-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-slot-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/55_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-slot-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/56_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-local-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/57_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-local-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased double-forwarded queued-local-before-await alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/58_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_local_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-local-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-root-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/59_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-root-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-root-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/60_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-root-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-root-aliased-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/61_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-root-aliased-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-root-chain-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/62_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-root-chain-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-root-aliased-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/63_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_alias_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-root-aliased-inline-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased queued-root-chain-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/64_async_main_guarded_const_backed_triple_root_triple_source_tail_queue_root_chain_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 queued-root-chain-inline-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/65_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-aliased-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/66_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-aliased-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-chain-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/67_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-chain-forwarded-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-aliased-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/68_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-aliased-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-chain-inline-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage await with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/69_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_inline_forward_await.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-chain-inline-forward-before-await 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/70_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-forwarded-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-aliased-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/71_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_alias_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-aliased-forwarded-before-spawn 组合形态
guarded const-backed triple-root-aliased triple-source-aliased row-aliased slot-aliased tail-aliased bundle-chain-forwarded alias-sourced composed-dynamic helper-forwarded nested fixed-array repackage spawn with sibling array element 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/72_async_main_guarded_const_backed_triple_root_triple_source_tail_bundle_chain_forward_spawn.ql 会单独锁住 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，把 helper task-handle surface 继续推进到 bundle-chain-forwarded-before-spawn 组合形态
const-backed + guard-refined projected-root alias-root canonicalization 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/15_async_main_aliased_guard_refined_const_backed_projected_root.ql 会单独锁住 let alias = pending.tasks; let slot = Slot { value: INDEX }; if slot.value == 0 { await alias[slot.value]; pending.tasks[0] = ... } await alias[0] 这条三者组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 25，把这条能力同样收口到公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已有真实 executable 示例：ramdon_tests/async_program_surface_examples/73_async_main_aliased_guard_refined_static_alias_backed_projected_root.ql 会单独锁住 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] 这条 static/use-alias 与 equality-guard 组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 35，把这条能力也收口到公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 nested aggregate submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/74_async_main_aliased_guard_refined_static_alias_backed_nested_repackage_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、nested aggregate repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 42，把这条能力也收口到更贴近真实对象封装与任务提交流程的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 helper-forwarded nested fixed-array submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/75_async_main_aliased_guard_refined_static_alias_backed_forwarded_nested_array_repackage_spawn.ql 会单独锁住 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] 这条 static/use-alias、equality-guard、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 58，把这条能力也收口到更贴近真实 helper 封装与任务提交流程的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/76_async_main_guarded_static_alias_sourced_composed_dynamic_forwarded_nested_array_repackage_spawn.ql 会单独锁住 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] 这条 static/use-alias、equality-guard、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 65，把这条能力也收口到更贴近真实复杂索引组合、helper 封装与任务提交流程的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 double-root alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、double-root alias-root canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 69，把这条能力也收口到更贴近真实多层任务根别名、复杂索引组合与 helper 封装提交流程的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 double-root double-source alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、double-root alias-root canonicalization、double-source alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 71，把这条能力也收口到更贴近真实多层任务根别名、多层索引源别名与 helper 封装提交流程的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 double-root double-source row-alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、double-root alias-root canonicalization、double-source alias canonicalization、row alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 73，把这条能力也收口到更贴近真实多层任务根别名、多层索引源别名与 row alias 组合的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 double-root double-source row/slot-alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、double-root alias-root canonicalization、double-source alias canonicalization、row alias canonicalization、slot alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 77，把这条能力也收口到更贴近真实多层任务根别名、多层索引源别名与 row/slot 双别名组合的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root double-source row/slot-alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、double-source alias canonicalization、row alias canonicalization、slot alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 79，把这条能力也收口到更贴近真实三层任务根别名与多层索引源别名组合的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source row/slot-alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、row alias canonicalization、slot alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 81，把这条能力也收口到更贴近真实三层任务根别名与三层索引源别名组合的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source row/slot/tail-alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、row/slot/tail alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 84，把这条能力也收口到更贴近真实三层任务根别名、三层索引源别名与 tail alias 组合的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source row/slot/tail-alias + forwarded-alias + alias-sourced composed dynamic + helper-forwarded nested fixed-array submit 的真实 executable 示例：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 会单独锁住 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] 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、row/slot/tail alias canonicalization、forwarded alias canonicalization、alias-sourced composed stable-dynamic path、helper forwarding、nested fixed-array repackage 与 submit lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 86，把这条能力也收口到更贴近真实 tail alias + forwarded alias 重组的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/85_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queued_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 88，把这条能力继续推进到 queued-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/86_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root alias before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 90，把这条能力继续推进到 queued-root-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-aliased-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/87_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_alias_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root extra immutable alias before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 92，把这条能力继续推进到 queued-root-aliased-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-chain-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/88_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_chain_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root extra immutable alias chain before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 94，把这条能力继续推进到 queued-root-chain-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-local-aliased-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/89_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_alias_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local immutable alias before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 96，把这条能力继续推进到 queued-local-aliased-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-local-chain-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/90_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_chain_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local immutable alias chain before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 98，把这条能力继续推进到 queued-local-chain-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-local-forwarded-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/91_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_forward_spawn.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local forwarded helper handoff before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 100，把这条能力继续推进到 queued-local-forwarded-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-local-inline-forwarded-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/92_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_inline_forward_spawn.ql 会单独锁住 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) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local inline helper handoff before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 102，把这条能力继续推进到 queued-local-inline-forwarded-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased bundle-inline-forwarded-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/93_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_inline_forward_spawn.ql 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、nested bundle slot inline helper handoff before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 104，把这条能力继续推进到 bundle-inline-forwarded-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased bundle-slot-inline-forwarded-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/94_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_spawn.ql 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、bundle slot projection inline helper handoff before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 106，把这条能力继续推进到 bundle-slot-inline-forwarded-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased tail-inline-forwarded-before-spawn helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/95_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_direct_inline_forward_spawn.ql 会单独锁住 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) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、direct tail field inline helper handoff before spawn、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 108，把这条能力继续推进到 tail-inline-forwarded-before-spawn 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased tail-inline-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/96_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_direct_inline_forward_await.ql 会单独锁住 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) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、direct tail field inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 110，把这条能力继续推进到 tail-inline-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased bundle-slot-inline-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/97_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_slot_inline_forward_await.ql 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、bundle slot projection inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 112，把这条能力继续推进到 bundle-slot-inline-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased bundle-inline-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/98_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_bundle_inline_forward_await.ql 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、nested bundle slot inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 114，把这条能力继续推进到 bundle-inline-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-local-inline-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/99_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_inline_forward_await.ql 会单独锁住 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) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 116，把这条能力继续推进到 queued-local-inline-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-local-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/100_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_local_forward_await.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued local forwarded helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 118，把这条能力继续推进到 queued-local-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-inline-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/101_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_inline_forward_await.ql 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 120，把这条能力继续推进到 queued-root-inline-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/102_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_forward_await.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root forwarded helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 122，把这条能力继续推进到 queued-root-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-aliased-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/103_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_alias_forward_await.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root aliased helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 124，把这条能力继续推进到 queued-root-aliased-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-chain-forwarded-before-await helper submit 的真实 executable 示例：ramdon_tests/async_program_surface_examples/104_async_main_guarded_static_alias_backed_triple_root_triple_source_tail_queue_root_chain_forward_await.ql 会单独锁住 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 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root chain helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 126，把这条能力继续推进到 queued-root-chain-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-aliased-inline-forwarded-before-await helper submit 的真实 executable 示例：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 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root aliased inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 128，把这条能力继续推进到 queued-root-aliased-inline-forwarded-before-await 的公开可运行子集
static/use-alias-backed + guard-refined projected-root alias-root canonicalization 现也已继续推进到 triple-root triple-source tail-aliased queued-root-chain-inline-forwarded-before-await helper submit 的真实 executable 示例：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 会单独锁住 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]) 这条 static/use-alias、equality-guard、triple-root alias-root canonicalization、triple-source alias canonicalization、tail alias canonicalization、queued root chain inline helper handoff before await、helper forwarding 与 nested fixed-array repackage lowering 的组合路径，并由 crates/ql-cli/tests/executable_examples.rs 在真实 toolchain 下构建运行、锁定退出码 130，把这条能力继续推进到 queued-root-chain-inline-forwarded-before-await 的公开可运行子集
已补充 ql-codegen-llvm / ql-driver / ql-cli 的 helper-argument end-to-end 回归：let task = worker(); let forwarded = forward(task); await forwarded 与 spawn forward(task) 现在都被显式锁住，避免 task-handle helper 形参路径在后续 backend / driver 收口中回退
当前仍保持 conservative 类型策略：ql-typeck 目前只开放 Task[T] 这一显式 task-handle 类型面，await 暂不引入 Future/effect 全类型建模，也不开放更广义的任务调度/cancellation 类型协议
当前仍不引入 first-class async callable type；await / spawn 先只接受可静态识别为 async fn 的调用路径，后续再结合 runtime/effect 设计决定是否放宽
当前 direct async fn call 已可直接作为 Task[T] 句柄值参与局部绑定、helper 参数/返回值与后续 await，但这仍不代表更广义的 async effect/type inference 已完成；更宽的 task-handle 生命周期与调度语义仍待后续设计
当前 borrowck 只对 direct-local task handle 建立最小 consume 合同；await / spawn、静态可判定的 helper Task[T] 参数传递和 direct-local return task 已经接入，tuple/struct-field 与 fixed-array literal index projected task-handle 也已有 precise consume/write-reinit 合同；dynamic fixed-array index task-handle 现已打开三层保守子集：generic dynamic consume 只保证 sibling-safe，generic dynamic write 只保证 maybe-overlap reinit，而 same immutable stable index path dynamic index 现也可获得 precise consume/write-reinit；另外 same-file const item 若能保守折回同一 literal/projection path，也会继承同样的 definite move / precise reinit 结果，最小 equality guard（如 if index == 0、if slot.value == 0）也已能在 dominated branch 内把 stable dynamic source path 回收到 literal/projection path；更广义的 arbitrary dynamic overlap reasoning 仍未完成，这不代表 dynamic index 的完整 place-sensitive lifecycle 已全部开放；更广义的 helper 返回/drop 边界、place-sensitive handle move/drop 与更广义提交协议仍待后续切片
当前 runtime crate 仍刻意不承诺 polling、cancellation、scheduler hints 或 Rust Future 绑定，只固定最小执行器接口
当前 hook ABI skeleton 已冻结第一版 LLVM-facing contract string，但仍只使用 ptr 级 opaque 形态；真实内存布局、结果传递协议和更细粒度调用约定仍未冻结
当前 Windows toolchain UX 已做 first-pass 收口：ql-driver 在 PATH / 显式 QLANG_CLANG / QLANG_AR 之外，还会 best-effort 探测常见 LLVM 安装路径（例如 Scoop 与标准 LLVM 安装目录），并在缺失诊断中附带候选路径；这改善的是 discover/hint 体验，不代表完整 linker family discovery 已完成
当前 backend/driver 对这些 hook 已进入“library-mode declaration + program-mode in-module runtime definitions/stub + __async_body / __async_entry / wrapper + frame hydration + scalar/task-handle/tuple/array/struct/void await lowering（含递归 nested aggregate-carried task-handle payload）+ task-handle-aware spawn lowering + fixed-array literal index projected consume + fixed-array for await lowering + staticlib / 最小 dylib library 子集开放 + BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable async fn main 最小程序入口子集开放，其中 executable 已可链接运行”阶段，但这仍不代表更广义的 async iteration 协议、任务结果协议、frame 生命周期管理或调度语义已经进入可执行阶段
当前 fixed-array literal lowering 也只打开了“已有具体 expected array type”的保守路径：direct temp 与 tuple / array / struct 聚合字面量内部的 [] 已可在 [T; N] 上下文中工作，但没有期望数组类型的裸 [] 仍不开放
当前 zero-sized async parameter 只在现有递归可加载 frame 模型内被视为合法：这锁住的是 [Int; 0]、Wrap { values: [Int; 0] } 与 [[Int; 0]; 1] 这类 frame 参数稳定性，不代表更广义的 capture/frame ABI 或 generic layout substitution 已经打开
当前 zero-sized async result 只在现有 loadable result 模型内被视为合法：这锁住的是 [Int; 0] 与递归 zero-sized aggregate 的 await/staticlib 稳定性，不代表更广义的 layout substitution、result transport 协议或 drop/cancellation 语义已经打开
当前 parameterless async fn wrapper 仍只依赖 async-task-create hook；带参数的 async fn 现在还会显式要求 async-frame-alloc hook 已接入，但这仍只是最小 heap-frame scaffold，不代表更完整的 frame/capture/result 设计已经冻结
当前 async-iteration 已不再只是纯失败合同：library-mode async body 与 BuildEmit::LlvmIr / BuildEmit::Object / BuildEmit::Executable async fn main 子集下的 fixed-array for await 都已走通 lowering 竖切片，且 program-mode executable 现已通过最小 in-module runtime support 进入可链接可运行的受控子集；但共享 runtime hook / capability 仍主要承担 ABI 预留语义，不代表通用 async iterator 调度协议已经冻结。P7.4 的 docs-first 评估结论也已明确：本轮不冻结 qlrt_async_iter_next，不开放 dynamic-array for await；若未来要扩面，优先考虑 compiler-driven 的 Slice[T] / span-like fixed-shape view
当前仍未引入完整 CFG 级 must-return / 全路径控制流分析；本轮只把有序表达式求值、显式字面量 if true / if false、显式字面量 match true/false、非字面量 Bool / enum match 上的字面量 guard、loop { return ... }、显式字面量 while true / while false 与 break-sensitive loop body 纳入 conservative 收口，一般 while / for 的更强迭代推理、更广义的常量传播、更一般的 guard-sensitive match 与 unreachable 细化仍待后续切片
当前 loop-control 已具备 analysis/LSP 的只读桥接，但还未扩展到公开 editor 协议 capability；继续保持低风险桥接策略

分阶段实现建议

P7.1 语义层收口

在现有 MIR async operator lowering 合同之上，继续把 await / spawn 当前“必须调用 async fn”的约束下沉到 runtime/codegen 接口契约（仍保持 conservative）
在 ql-resolve / ql-analysis 增补 async 语义查询契约
保持 conservative 策略，不提前承诺完整 effect 系统

P7.2 MIR 与 ownership 规则扩展

为 async 边界补最小可验证 lowering 规则
定义 spawn 的 capture 与 escape 约束
先覆盖 deterministic 子集，再讨论更复杂调度

P7.3 Runtime 与 executor 抽象

已落地最小 Executor trait 与单线程 InlineExecutor
把 runtime 调度边界隔离在独立 crate
与 codegen 的调用约定通过明确定义对齐

P7.4 Rust 互操作闭环

在已提交 examples/ffi-rust 的基础上继续扩展构建矩阵与宿主场景
固化 C ABI 映射和错误输出格式
文档中给出可复现的构建矩阵

测试策略

单元测试锁语义规则和诊断文本
集成测试覆盖 CLI、FFI、样例工程
失败快照优先于“盲目支持更多语法”
每个切片必须包含边界回归用例

非目标

当前阶段不做 project-wide async optimizer
当前阶段不做完整 actor runtime
当前阶段不做跨平台高性能网络栈

出口标准

async fn / await / spawn 在语义层有稳定结果与诊断
至少一条 Rust 混编路径可在 CI 复现
文档、测试、实现三者保持同一事实面

Phase 7 并发、异步与 Rust 互操作 ​

目标 ​

当前基础 ​

当前进度（2026-04-01） ​

分阶段实现建议 ​

P7.1 语义层收口 ​

P7.2 MIR 与 ownership 规则扩展 ​

P7.3 Runtime 与 executor 抽象 ​

P7.4 Rust 互操作闭环 ​

测试策略 ​

非目标 ​

出口标准 ​

Phase 7 并发、异步与 Rust 互操作

目标

当前基础

当前进度（2026-04-01）

分阶段实现建议

P7.1 语义层收口

P7.2 MIR 与 ownership 规则扩展

P7.3 Runtime 与 executor 抽象

P7.4 Rust 互操作闭环

测试策略

非目标

出口标准