feat(compile): native ADO pipeline IR

[jamesadevine]

Replaces the YAML-string composition pipeline compiler with a typed Rust IR. Every production compile target (standalone, 1ES, job, stage) now builds a Pipeline value and lowers it through a single serde_yaml emit. All four src/data/*-base.yml templates are deleted. The CompilerExtension trait surface is reduced to name / phase / declarations, with every signal (steps, hosts, MCPG entries, prompt fragments, AWF mounts, env vars, warnings) returned as a typed Declarations aggregate.

Companion to merged prep PR #957 (canonical serde_yaml normalisation across all lock files), which makes this PR''s diff purely structural.

What landed

Foundation (src/compile/ir/)

• 080bf10d typed pipeline IR (ids, step, job, stage, env, condition, output)
• f2b76455 lower.rs + emit.rs with round-trip tests
• cd3af4d3 graph.rs — Kahn cycle detection, per-stage dependsOn derivation from OutputRef graph
• ec50b1fa per-location OutputRef lowering — same-job macro / cross-job dependencies.<job>.outputs[...] / cross-stage stageDependencies + auto-isOutput=true
• 87759d2e Condition AST + codegen with Custom-injection rejection
• 1253187f top-level parameters / resources / triggers / variables lowering

Extension ports (one commit each)

All extensions now return typed Declarations with Step::Bash / Step::Task / Step::Download / Step::Publish values: AdoAwMarker, GitHub, SafeOutputs, AzureCli, Lean/Python/Node/Dotnet, AzureDevOps/CacheMemory, AdoScript (the marquee — typed synthPr step with OutputDecls, prGate consumes via OutputRef, unlocks declarative cross-stage synth-PR propagation), ExecContext (PR contributor uses EnvValue::Coalesce(vec![Macro(SYS_PR_*), StepOutput(synthPr.*)]) instead of hand-written $[ coalesce(...) ] strings).

Compile-target migrations (every *-base.yml deleted)

• dfba833c standalone → src/compile/standalone_ir.rs; delete base.yml
• 468359f6 extract canonical-jobs builder + extend IR for template targets (StageExternalParamsWrap, TemplateDependsOnWrap)
• 9f400732 stage → src/compile/stage_ir.rs; delete stage-base.yml
• 63b489ee job → src/compile/job_ir.rs; delete job-base.yml
• 770e99df 1es → src/compile/onees_ir.rs; delete 1es-base.yml (−647 lines net); PipelineShape::OneEs lowering with templateContext.outputs[] for Step::Publish lifting

Cleanup (IR_PLAN.md)

• 7c41c6a9 retire-agentic-depends-on — delete every generate_* / format_* / compile_shared / compile_template_target helper from common.rs (−3 234 lines)
• 63f3af18 lockfile-rebaseline — recompile every tests/safe-outputs/*.lock.yml at v0.35.3 (diff is purely version-bump churn → byte-confirms the IR path is semantically identical)
• 5199c425 Wave A — delete legacy prepare_steps / setup_steps trait methods + enum delegations
• 385cba75 Wave B — fold the other 10 accessors (required_hosts, required_bash_commands, prompt_supplement, mcpg_servers, allowed_copilot_tools, validate, required_pipeline_vars, required_awf_mounts, awf_path_prepends, agent_env_vars) into declarations(). Trait surface is now exactly name / phase / declarations.
• 5796a72d rewrite docs/extending.md, replace docs/template-markers.md with docs/ir.md, refresh AGENTS.md and site/src/content/docs/ for the typed IR

Pragmatic deviations from IR_PLAN.md

1. declarations() started as a default trait impl that wrapped Step::RawYaml around legacy Vec<String> outputs. This kept all ~150 existing call sites compiling during the per-extension rollout. The default impl is now gone (Wave B); every extension provides typed values directly.
2. Step::RawYaml survives — standalone_ir::build_setup_job / build_teardown_job use it for user-authored setup/teardown YAML (the IR does not model arbitrary user-authored ADO step shapes). Audit grep for RawYaml only matches those legitimate sites + IR type/lowering.
3. Setup / Teardown stay unprefixed even under target: job|stage|1es — JobPrefix::id returns the unprefixed base for Setup / Teardown to match the legacy *-base.yml literal emission.
4. 1ES jobs use templateContext: instead of per-job pool: — Job::template_context: Option<JobTemplateContext> causes the lowering pass to suppress pool: and lift Step::Publish entries into templateContext.outputs[].

Validation

Run on every commit:

• cargo build — clean
• cargo test — 1813+ unit + integration tests passing
• cargo clippy --all-targets --all-features — clean
• cargo test --test bash_lint_tests — clean (shellcheck against every literal bash: body in emitted YAML)

Final spot-check: find src/data -name "*-base.yml" returns nothing — no YAML survives in source. grep -r "##vso\[task.setvariable" src/ and grep -r "dependencies\." src/ only match the IR lowering pass — no hand-built reference strings remain in extensions or common.rs.

Stats

27 commits. Net: ~−5 000 lines (deleted four *-base.yml templates totalling ~131 KB and the entire YAML-string composition layer; added typed IR + per-target builders + docs/ir.md).

[github-actions]

🔍 Rust PR Review

Summary: Solid IR foundation — well-structured, well-tested, and good error handling throughout. Two issues worth addressing before real callers are wired up.

Findings

🐛 Bugs / Logic Issues

• src/compile/ir/graph.rs:184–202 — cross-job duplicate StepIds silently overwrite in step_locations

  The duplicate-ID guard only fires when prev.stage == stage && prev.job == job.id (same job). For two different jobs that both declare a step named e.g. synthPr, the second g.step_locations.insert(...) silently overwrites the first. Any OutputRef to synthPr then resolves to whichever job was indexed last — wrong dependsOn derivations and wrong reference syntax. Currently safe only by convention (ado-aw generates unique IDs), but the invariant isn't enforced by the type system. Suggest either (a) making the map key (Option<StageId>, JobId, StepId) or (b) erroring on any cross-job duplicate.

• src/compile/ir/graph.rs:380–383 — misleading comment contradicts the code and the test

  The comment says "add stage edge AND surface a cross-job edge", but the code only inserts into g.stage_edges (no g.job_edges.insert in the cross-stage branch). The test at line 694 explicitly asserts stage_b.jobs[0].depends_on.is_empty(), confirming the correct behavior. The comment should read something like: "Only add a stage-level edge; ADO infers per-job ordering from the stage-level dependsOn — no cross-job edge is needed here."

⚠️ Suggestions

• src/compile/ir/lower.rs:448–462 — lower_outputref_for_expr silently emits semantically broken ADO for same-job step outputs

  When producer and consumer are in the same job, lower_outputref returns $(step.name). The function strips the $() and emits variables['step.name'] — which ADO's runtime expression engine also cannot resolve for step outputs (the comment acknowledges this). Instead of letting callers produce syntactically valid but semantically dead YAML, consider bail!-ing: same-job StepOutput inside a Coalesce is a programming error the IR should reject rather than silently mangle.

• src/compile/ir/lower.rs:229–249 — lower_raw_yaml de-indent uses unwrap_or(line) as a silent fallback

  For a - -prefixed body, continuation lines with fewer than 2 leading spaces are passed through unchanged rather than failing. serde_yaml will catch truly broken output, but an explicit error when a continuation line has unexpected indentation would make future debugging much faster when a legacy emitter changes its formatting.

✅ What Looks Good

• IR validation coverage is thorough: unknown producers, anonymous producers, unknown outputs, duplicate IDs, and cycles all have dedicated error paths and unit tests. The five-stage chain test is a nice stress test of the full transitive-edge derivation.
• Condition::Custom injection check correctly blocks ##vso[/##[ and embedded newlines while explicitly allowlisting ADO runtime expressions — the separation of compile-time safety from runtime expressiveness is sound.
• EnvValue::AdoMacro allowlist with anyhow::Result construction is a great pattern — typos in ADO predefined-variable names are caught at compile time rather than silently producing $(Bad.Var) at pipeline runtime.
• detect_cycles_in Kahn's algorithm is correctly implemented; the .expect("node must be in in_degree") is load-bearing and the invariant holds (every consumer and producer node is inserted into in_degree during edge enumeration).
• Step::RawYaml migration bridge design is clean — the per-extension port-* commit strategy, #[allow(dead_code)] scoping, and explicit removal commit in the plan are all well-considered.

Generated by Rust PR Reviewer for issue #960 · sonnet46 3.2M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Solid foundation — the IR design is clean and well-motivated. One correctness bug to address before the compile-target-* commits land; a few smaller items noted below.

Findings

🐛 Bugs / Logic Issues

• step_locations keyed only on StepId → cross-job collision (src/compile/ir/graph.rs:172-206)

  step_locations: BTreeMap<StepId, StepLocation> uses StepId as the sole key. In ADO, step names are only unique within a job — two different jobs may legally have a step named synthPr. When index_job_steps encounters a second job with a conflicting step ID, line g.step_locations.insert(id.clone(), StepLocation { ... }) silently overwrites the first entry. The inline comment acknowledges cross-job duplicates "are technically allowed", but the fix (rejecting the overwrite) is never done.

  Downstream consequences:

  1. add_edge_for_ref resolves the wrong job as the producer, so dependencies.WrongJob.outputs['step.X'] would be emitted.
  2. apply_auto_is_output walks all steps and marks any step sharing that StepId (in any job) with auto_is_output = true, even unrelated ones.

  The current extension layout (globally-unique IDs: synthPr, prGate, ...) means this won't bite yet, but it must be fixed before the compile-target-* commits wire the IR to production. Suggested fix: either enforce globally-unique StepIds in build_graph validation, or use a compound key (Option<StageId>, JobId, StepId) and require OutputRef to carry the job context too.

• unimplemented!() panic instead of structured error (src/compile/ir/lower.rs:96-103)

  PipelineShape::OneEs { .. } | PipelineShape::JobTemplate { .. } | ... => {
      unimplemented!("PipelineShape wrapping is introduced by the compile-target-* commits");
  }

  unimplemented!() is a hard panic (no Result). If any test or future caller inadvertently passes a non-Standalone pipeline to lower() during the migration window, the error message is unhelpful and the callsite gets no anyhow context chain. Prefer anyhow::bail! which returns Err and lets the caller surface it gracefully.

⚠️ Suggestions

• Condition::And(vec![]) / Or(vec![]) produces invalid ADO syntax (src/compile/ir/condition.rs)

  lower_condition for Condition::And(parts) emits and() when parts is empty. and() / or() with zero arguments is not valid ADO condition syntax (runtime error). The Condition::and() / Condition::or() constructors accept empty iterators without complaint. A guard in lower_condition (bail if flat.is_empty()) would catch authoring errors early with a clear message rather than letting them surface as cryptic ADO runtime failures.

• expect() in lower_outputref is load-bearing on graph-validation ordering (src/compile/ir/output.rs:141)

  let prod_stage = producer.stage.expect("cross-stage ref must have producer stage (graph validation enforces)");

  The expect fires if lower_outputref is ever called without a prior build_graph pass (e.g., in a future direct test). The contract is documented, but replacing with ok_or_else(|| anyhow::anyhow!("...")) propagates cleanly through lower_outputref's caller chain (changing the return type from String to Result<String>) rather than panicking. Given that lower_outputref is pub, this is worth tidying.

• Minor doc/impl mismatch in EnvValue::Coalesce (src/compile/ir/env.rs + lower.rs)

  The doc-comment says "Nested Coalesce is flattened during lowering" but lower_env_value_as_expr_atom actually emits coalesce(coalesce(a, b), c) for nested Coalesce — structurally nested, not flat. The "flattening" intended is just that the outer $[ ... ] wrapper doesn't repeat, which is correct. Amending the doc to "The outer $[ ... ] wrapper is not repeated for nested Coalesce" avoids confusion for future contributors reading the IR.

✅ What Looks Good

• Kahn cycle detection (graph.rs:417-467): correct BFS-over-in-degree-0 implementation; the adjacency map is oriented producer → [consumer] (right direction for topological order); visited != in_degree.len() cycle test is sound.

• ADO reference-syntax table (output.rs): the three-form dispatch (same-job $(step.X) / cross-job dependencies.J.outputs[...] / cross-stage stageDependencies.S.J.outputs[...]) is correctly implemented and the four unit-test cases in output::tests lock every branch.

• Condition::Custom injection guard (condition.rs:validate_custom_condition): rejects ##vso[ and ##[ pipeline-command prefixes and embedded newlines while deliberately allowing ADO expressions ($(...), $[...], ${{...}}). The two rejection tests are specific and clear.

• Typed-ID newtype via define_id! (ids.rs): the macro-generated StageId / JobId / StepId enforce the ADO identifier grammar (^[A-Za-z_][A-Za-z0-9_]*$) at construction with anyhow::Result, making misuse a compile-time / immediate-runtime error instead of a silent wrong-YAML field.

• Default declarations() migration bridge: wrapping prepare_steps / setup_steps results as Step::RawYaml in the trait default preserves all ~150 legacy call sites without change and makes the per-extension port-* commits independently reviewable — clean incremental strategy.

• Marquee tests (ado_script.rs::typed_gate_pr_id_lowers_to_macro_concat_in_same_job, exec_context/mod.rs::exec_context_pr_step_lowers_to_cross_job_dep_form_in_agent_job): these build real Pipeline structs, run the full lowering pass, and assert the exact env-var values in the emitted YAML — exactly the right level of coverage for the ADO macro/expression duality that caused bugs in the past.

• EnvValue::AdoMacro(&'static str) allowlist (env.rs): requiring construction through the ALLOWED_ADO_MACROS gate catches predefined-variable typos at Rust compile time / declarations() call time instead of silently producing $(Bad.Var) at pipeline runtime. The env_value_from_ado_macro fallback in filter_ir.rs preserves backward compat for not-yet-listed variables while still emitting a functionally equivalent scalar.

Generated by Rust PR Reviewer for issue #960 · sonnet46 3.9M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Solid IR foundation with 97 new tests and clean design — two latent bugs worth fixing before this path handles staged pipelines.

Findings

🐛 Bugs / Logic Issues

• src/compile/ir/graph.rs — build_graph skips stage-level conditions: Pass 2 calls add_edges_from_job for every job in every stage, but never walks Stage::condition for OutputRefs. Consequence: a stage condition containing Expr::StepOutput(...) (1) won't validate the producer reference, (2) won't add the cross-stage edge to g.stage_edges, and (3) won't populate Stage::depends_on via apply_edges. The pipeline would emit a condition: stageDependencies.X... with no dependsOn: — which ADO may silently accept or reject. Today this is unreachable (standalone uses flat Jobs), but it's the stated goal of the staged-pipeline path. Fix: add a add_edges_from_stage_condition sweep alongside the job loop in pass 2.

• src/compile/ir/lower.rs:108 — unimplemented!() panic in lower_with_graph: The match arm for OneEs | JobTemplate | StageTemplate calls unimplemented!() rather than returning a proper Err(anyhow::bail!(...)). Currently safe because standalone_ir.rs always produces PipelineShape::Standalone, but lower_with_graph is pub and the contract is only enforced by convention. Should return an error variant rather than panic.

⚠️ Suggestions

• src/compile/ir/output.rs:142 — .expect() in pub lower_outputref: The cross-stage branch asserts producer.stage.expect("cross-stage ref must have producer stage (graph validation enforces)"). The function signature is pub fn ... -> String, not Result<String>, so it relies entirely on callers having run build_graph first. The two private wrappers (lower_outputref_for, lower_expr) respect this contract, but the public surface doesn't enforce it. Suggest either making the function pub(crate) or changing the return to Result<String>.

• src/compile/ir/lower.rs — lower_raw_yaml 2-space de-indentation assumption: The strip_prefix(" ") stripping assumes the sequence marker - is immediately followed by the mapping key and all continuation lines have exactly 2 spaces of sequence indent. This holds for all current extension YAML shapes, but would silently corrupt content from any future extension that uses 4-space or tab continuation. Adding a brief doc-comment specifying the expected format (and ideally a test covering the de-indented path directly) would make the invariant explicit.

✅ What Looks Good

• Typed IDs with ADO grammar validation — StageId / JobId / StepId construction validates the ^[A-Za-z_][A-Za-z0-9_]*$ pattern at the callsite; this is the right place for it.
• ALLOWED_ADO_MACROS allowlist — rejecting unknown EnvValue::AdoMacro names at construction time is excellent; a typo that would silently produce $(Bad.Var) at runtime is now a build error.
• Condition::Custom injection checks — validate_custom_condition correctly rejects ##vso[ / ##[ markers and embedded newlines while permitting $() / $[] / ${{}} ADO expressions (which is exactly the right trade-off for an escape hatch).
• Two-pass graph build — index-then-resolve cleanly prevents forward-reference failures and separates duplicate-detection from edge-derivation.
• Kahn cycle detection is correctly implemented with full node tracking; the expect("node must be in in_degree") in the inner loop is justified by the construction invariant a few lines above.
• RawYaml migration bridge with a documented exit path is a pragmatic and transparent choice for the ~150 legacy call sites.

Generated by Rust PR Reviewer for issue #960 · sonnet46 4.7M · ◷

[jamesadevine]

@copilot resolve merge conflicts

[Copilot]

@copilot resolve merge conflicts

Merge conflicts resolved (commit 4cd0d71):

• tests/compiler_tests.rs: Updated assertions to use the new $(AW_PR_ID) / $(AW_PR_TARGETBRANCH) macro form from origin/main (the new unified variable namespace from fix(compile): unify synthetic-PR variable namespace via ado-script #972/fix(ado-script): treat unsubstituted ADO macros as empty in synthPr #975).
• src/data/base.yml: Kept the intentional deletion from this branch — the standalone target now builds from the Pipeline IR directly, so the template file is no longer needed.

Build and tests green.

[jamesadevine]

/rust-review

[github-actions]

✅ Rust PR Reviewer completed successfully!

[github-actions]

🔍 Rust PR Review

Summary: Strong progress — standalone_ir.rs cleanly replaces base.yml with typed IR, and the parameter/resource/trigger lowering in lower.rs is correct and well-tested. One new silent-failure bug in the latest commits; four previously-flagged items remain open.

Findings

🐛 Bugs / Logic Issues

• src/compile/standalone_ir.rs — parse_env_block silently drops all env vars on YAML parse failure (NEW)

  let parsed: serde_yaml::Value = match serde_yaml::from_str(yaml_block) {
      Ok(v) => v,
      Err(_) => return Vec::new(),  // ← silent drop
  };

  Called in run_copilot_step with a synthetic_block constructed by indenting engine_env lines under an env: key. If any engine-env value (including extension-contributed agent_env_vars) contains YAML-special characters (:, #, multi-line text), serde_yaml::from_str returns Err and all env vars are silently dropped — no compile error, no warning. The agent step would then run without its required env vars. Suggest changing the return type to Result<Vec<_>> and propagating with .context("parse_env_block: malformed engine env block").

• src/compile/ir/lower.rs:96–103 — unimplemented!() panic instead of anyhow::bail! (PERSISTENT — 2nd time flagged)

  PipelineShape::OneEs | JobTemplate | StageTemplate hits unimplemented!(). lower_with_graph is pub; any test that accidentally constructs a non-Standalone pipeline and calls emit will panic with no anyhow context chain. Replace with anyhow::bail!.

• src/compile/ir/graph.rs:185–206 — step_locations keyed only on StepId, cross-job collision (PERSISTENT — 3rd time flagged)

  Still BTreeMap<StepId, StepLocation>. Two jobs sharing a StepId silently overwrite. OutputRefs pointing to that ID resolve to whichever job was indexed last — wrong dependencies.* syntax at emit time. Fix: use a compound key or enforce global uniqueness in validation.

• src/compile/ir/graph.rs — Stage::condition not walked in Pass 2 (PERSISTENT — 2nd time flagged)

  add_edges_from_job is called for every job in every stage, but the stage-level condition field is never scanned for Expr::StepOutput refs. A stage condition with a cross-stage StepOutput reference would silently miss its dependsOn edge and fail at ADO runtime.

⚠️ Suggestions

• src/compile/ir/condition.rs — Condition::And([])/Or([]) emits and()/or() — invalid ADO syntax (PERSISTENT — 2nd time flagged)

  lower_condition for And(parts) calls flatten_and(parts) which can return an empty slice, emitting and(). ADO's runtime condition evaluator errors on zero-arg and()/or(). Add a guard: if flat.is_empty() { bail!("Condition::And requires at least one operand") }.

✅ What Looks Good

• standalone_ir.rs end-to-end replacement of base.yml is clean: build_standalone_pipeline composes typed jobs, wire_explicit_dependencies sets explicit dependsOn edges, and emit::emit round-trips correctly through the lock-file test suite. Deleting base.yml is the right call.
• lower_parameters / lower_resources / lower_pr_trigger / lower_ci_trigger all correctly handle empty / None / disabled cases and elide empty keys — output matches the canonical lock-file format.
• parse_env_block heuristic ($(X) → PipelineVar, other strings → Literal, non-string scalars → RawYamlScalar) correctly threads all three ADO env-value shapes through the IR without losing type information.
• Condition::Eq(Expr::StepOutput(...)) on SafeOutputs job condition is the first production use of typed cross-job OutputRef in a condition — the lowering correctly selects dependencies.Detection.outputs['threatAnalysis.SafeToProcess'] and the lock-file tests confirm it.

---

Generated by Rust PR Reviewer for issue #960 · sonnet4-6 · ◷

Generated by Rust PR Reviewer for issue #960 · sonnet46 3M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Solid architectural foundation — the IR type design is clean, the Kahn cycle detection is correct, and the security controls (Condition::Custom injection check, ADO macro allowlist) are well-thought-out. A few specific issues to address before merge.

Findings

🐛 Bugs / Logic Issues

• src/compile/standalone_ir.rs:78–90 — build_standalone_pipeline has its entire doc comment duplicated back-to-back. Looks like a merge artifact. The second copy starting at line ~84 should be removed.

• src/compile/ir/lower.rs:113–116 — lower_with_graph uses unimplemented!() for PipelineShape::OneEs:

  PipelineShape::OneEs { .. } => {
      unimplemented!("PipelineShape::OneEs wrapping is introduced by the compile-target-1es commit");
  }

  unimplemented!() panics without any anyhow context. A caller who constructs a PipelineShape::OneEs and calls emit() gets a bare panic with no context chain. OneEsSdlConfig is publicly constructible (pub reserved: ()), so this path is reachable from safe code outside the crate. Should be anyhow::bail!("...") for consistent error surfacing.

⚠️ Suggestions

• src/compile/standalone_ir.rs:1105–1120 — wire_explicit_dependencies calls prefix.id(...).expect(...) four times but returns (). The invariant that generate_stage_prefix always produces valid ADO identifier chars is strong today but isn't encoded in the type system. Changing the signature to fn wire_explicit_dependencies(...) -> Result<()> and using ? would eliminate the panic class for three extra lines.

• src/compile/ir/lower.rs:985–1000 (lower_outputref_for_expr, same-job path) — The comment documents that a Coalesce child pointing at a same-job OutputRef silently emits variables['step.name'], which ADO cannot resolve at runtime. There's no compile-time or graph-pass guard preventing a future extension from constructing this combination. Consider adding a graph-pass validation rule (or at minimum a debug_assert) that rejects Coalesce containing a same-job OutputRef.

✅ What Looks Good

• Two-pass design (build_graph → lower_with_graph) is architecturally sound; graph errors surface before any YAML is emitted.
• Kahn's algorithm is correct and reports all nodes involved in a cycle — good UX.
• Condition::Custom validation correctly blocks ##vso[ / ##[ injection and embedded newlines while deliberately passing ADO expressions ($(...), $[...], ${{ }}).
• EnvValue::AdoMacro closed-set allowlist prevents silent runtime typos from expanding to literal $(Bad.Var).
• OutputRef three-way syntax selection ($(step.X) / dependencies.* / stageDependencies.*) matches the ADO spec and is well-tested.
• RawYaml migration bridge is clearly documented with a concrete removal commit name.
• #[allow(dead_code)] scope is minimised and the removal plan is clearly tied to named commits.

Generated by Rust PR Reviewer for issue #960 · sonnet46 6.2M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Solid IR foundation — typed identifiers, well-tested graph pass, good injection checks. A few minor issues to address before merge.

Findings

🐛 Bugs / Logic Issues

• src/compile/ir/lower.rs:108 — unimplemented!() panic instead of bail!()
lower_with_graph (which backs the public emit() entrypoint) panics via unimplemented!() for PipelineShape::OneEs. The function signature is Result<Value>, and the project convention uses bail!() or .context() — never unimplemented!() / panic!() in production return paths. Today this arm is unreachable (no call site constructs OneEs yet), but the 1ES port commit will do exactly that, and a panic will silently bypass the anyhow error chain. Change to:

  PipelineShape::OneEs { .. } => bail!(
      "PipelineShape::OneEs lowering is not yet implemented \
       (introduced by compile-target-1es)"
  ),

• src/compile/standalone_ir.rs:1846 — .unwrap() in non-test production path
  threat_analysis_step() calls StepId::new("threatAnalysis").unwrap() inside a plain fn that returns BashStep, not Result<BashStep>. "threatAnalysis" always passes validation, so this won't panic, but:
  (a) it violates the no-unwrap-on-user-facing-paths convention, and
  (b) it silently blocks the function from being upgraded to return Result<BashStep> if the script body ever needs to do fallible work.
  Either promote the return type to Result<BashStep> and use ?, or hoist the StepId to a static / const outside the function.

• src/compile/standalone_ir.rs:1149–1153 — .expect() in wire_explicit_dependencies
wire_explicit_dependencies returns () but calls .expect("Setup ID") etc. on four JobId::new(...) calls. All four are compile-time string constants that pass JobId validation, so they cannot panic today. However, the function signature cannot propagate errors to its caller — if someone adds a dynamic ID here the compiler forces them to .expect() or .unwrap(). Change the signature to fn wire_explicit_dependencies(jobs: &mut [Job], prefix: &JobPrefix<'_>) -> Result<()> and use ?.

⚠️ Suggestions

• src/compile/standalone_ir.rs:72–83 — duplicate doc comment
  The entire doc paragraph for build_standalone_pipeline appears verbatim twice (lines 72–77 then 78–83). Remove the first copy; the second one immediately precedes the #[allow(clippy::too_many_arguments)] line and is the correct placement.

• src/compile/standalone_ir.rs — Condition::Custom for synth-PR / gate conditions bypasses graph validation
  build_agentic_condition encodes ne(dependencies.Setup.outputs['synthPr.AW_SYNTHETIC_PR_SKIP'], 'true') etc. as Condition::Custom strings. This means the graph pass cannot validate those step IDs / output names, and the validate_custom_condition injection check only runs at codegen time (not compile-validation time). The Setup → Agent edges are covered by wire_explicit_dependencies, so generated YAML is correct. The PR description acknowledges these will be migrated to typed Condition::Ne(Expr::StepOutput(...)) by follow-on port commits — just flagging it here so the migration doesn't get left behind indefinitely.

• src/compile/ir/lower.rs:900 — silent drop on serialization error
  yaml_value_to_scalar_string ends with serde_yaml::to_string(other).unwrap_or_default().trim(). If a Sequence or Mapping YAML value somehow appears in the RawYamlScalar escape hatch and fails to serialise, the error is silently swallowed and an empty string is emitted. Given this is already a best-effort escape hatch this may be acceptable, but unwrap_or_else(|_| String::new()) with a log::warn! would be safer.

✅ What Looks Good

• Graph validation (ir/graph.rs) — the two-pass design (index → walk) is clean. Kahn's algorithm for cycle detection is correct, and the error messages include the offending node set. The mixed staged/un-staged rejection is correct and well-tested.

• lower_outputref + ConsumerLocation/ProducerLocation newtype split — using distinct types prevents consumer/producer mixups at the call site, and the three-syntax dispatch table is easy to reason about.

• validate_custom_condition injection check (ir/condition.rs) — correctly rejects ##vso[ / ##[ pipeline-command markers and embedded newlines while explicitly allowing ADO expression syntax ($(...), $[...], ${{ }}). Tests cover both rejection paths.

• StageId/JobId/StepId newtype IDs with validated construction — returning Result from ::new() and using them as typed map keys throughout the graph pass is exactly the right model; the Display + AsRef<str> impls slot into format strings cheaply.

• Declarations default impl bridging legacy prepare_steps/setup_steps — the Step::RawYaml migration bridge is well-documented and the per-extension port pattern is sound. Using #[allow(dead_code)] at the struct level (rather than scattering it on fields) keeps the intent visible.

• Safety of the marquee SafeOutputs job condition — the typed OutputRef for threatAnalysis.SafeToProcess correctly picks up the prefixed {prefix}_Detection job at lowering time via the graph's step_locations, so the cross-job dependency reference auto-adjusts for target: job/stage without hard-coding the job name. This is the right design.

Generated by Rust PR Reviewer for issue #960 · sonnet46 4.8M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Good progress — the unimplemented!() panic in lower_with_graph is fixed and the three new compile-target modules (job_ir, stage_ir, onees_ir) are clean. Four issues from prior rounds remain open; two are notable enough to address before merge.

Findings

🐛 Bugs / Logic Issues

• src/compile/ir/graph.rs:74,185–202 — step_locations still uses BTreeMap<StepId, StepLocation> (cross-job collision) (flagged 3 prior rounds)

  The duplicate-ID guard (lines 185–192) only fires when prev.stage == stage && prev.job == job.id — i.e. the exact same job. When two different jobs each declare a step named e.g. synthPr, the second g.step_locations.insert(...) silently overwrites the first. Every subsequent add_edge_for_ref call resolves that StepId to whichever job was indexed last, producing wrong dependencies.<WrongJob>.outputs[...] syntax at emit time. apply_auto_is_output similarly marks the wrong job's step.

  Today ado-aw generates globally-unique step IDs, so this won't fire in production yet. But the comment on line 181 acknowledges the ambiguity ("technically allowed if both jobs are referenced through the qualifying job name") without actually fixing it, and the compile-target-* commits that wire user-authored step IDs are exactly the callsite that could break this.

  Suggested fix: either (a) use a compound key (Option<StageId>, JobId, StepId) throughout the graph and OutputRef, or (b) add a global-uniqueness validation pass in build_graph that errors when the same StepId appears in two different jobs.

• src/compile/standalone_ir.rs:1984–1986 — parse_env_block silently drops all env vars on YAML parse failure (flagged 2 prior rounds)

  Err(_) => return Vec::new(),  // ← silent drop

  The synthetic_block passed to parse_env_block at call-sites (lines 1529, 1602, 1624) is constructed by indenting engine_env values under an env: key. If any extension-contributed env value contains YAML-special characters (unquoted :, #, multi-line text), serde_yaml::from_str returns Err and all env vars for that step are silently dropped — no compile error, no warning. The agent step would run without its required env vars.

  Change parse_env_block to return Result<Vec<_>> and propagate with .context("parse_env_block: malformed engine env block — check for YAML-special characters in extension-contributed env values"). The three call-sites should ?-propagate into their Result<_> functions.

⚠️ Suggestions

• src/compile/standalone_ir.rs:72–83 — duplicated doc comment (flagged in prior round as merge artifact)

  Lines 72–77 and 78–83 contain an identical /// Build the typed [Pipeline]... doc comment. One copy should be removed.

• src/compile/standalone_ir.rs:1150–1153 and :1846 — .expect() / .unwrap() in non-test production code

  wire_explicit_dependencies calls .expect("Setup ID") etc. on four JobId::new(...) calls, and threat_analysis_step calls StepId::new("threatAnalysis").unwrap(). All six string literals are compile-time constants that always pass validation, so there's no panic risk today. But the functions can't propagate errors if a dynamic ID is ever threaded through, and they violate the project convention of no unwrap/expect outside tests. Promoting both to Result<_> return types (or hoisting to static/const for the StepId) would close the gap at the cost of ~10 lines.

✅ What Looks Good

• unimplemented!() eliminated from lower_with_graph — the OneEs / JobTemplate / StageTemplate arms all handle properly now; no more bare panics in the pub emit() path.
• job_ir.rs, stage_ir.rs, onees_ir.rs — the three new compile-target builders are clean: no panics, proper Result propagation, well-scoped responsibilities.
• Condition::Custom injection check runs at codegen time (lower_condition → validate_custom_condition) and correctly rejects ##vso[ and embedded newlines while intentionally permitting ADO expression syntax.
• Kahn cycle detection in graph.rs is correct and well-tested.

Generated by Rust PR Reviewer for issue #960 · sonnet46 2.3M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Looks good overall — this is a well-engineered structural rewrite. Two concrete concerns worth addressing before merge.

Findings

🐛 Bugs / Logic Issues

• src/compile/ir/output.rs + src/compile/ir/graph.rs — auto_is_output is set but never read at emit time.

  output.rs's doc-comment promises:

  "The compiler auto-emits isOutput=true ... the actual bash rewrite is performed at emit time by the producer's extension."

  graph.rs::apply_auto_is_output correctly sets the flag. But lower.rs, standalone_ir.rs, and all extensions have zero occurrences of auto_is_output. No extension performs the promised bash-body rewrite.

  This is not a current runtime bug — every OutputDecl producer either (a) runs a JS bundle that calls setOutput directly (synthPr), or (b) has isOutput=true hardcoded in the bash body (threatAnalysis). But the mechanism is unimplemented and the doc-comment advertises it as the contract. Any future contributor who adds an OutputDecl to a typed BashStep without hardcoding isOutput=true in the script body will silently produce empty values for all cross-step consumers — the graph pass will faithfully set auto_is_output = true and nothing will act on it.

  Recommend either: (a) implement the bash-body rewrite in lower_bash using auto_is_output, or (b) update output.rs's doc-comment to say "extension authors are responsible for ensuring isOutput=true is present in the bash body".

• src/compile/extensions/ado_script.rs (SYNTH_PR_OUTPUT_NAMES comment) — incorrect claim about OutputRef usage:

  // Legacy `AW_SYNTHETIC_PR_*` identifier names. The runtime no
  // longer emits these (see PR #972) but the typed gate-step
  // emitter in `filter_ir.rs::build_gate_step_typed` still
  // references them via OutputRef.

  filter_ir.rs has zero OutputRef usages. build_gate_step_typed uses EnvValue::pipeline_var("AW_PR_ID") etc. — no OutputRef involved. The legacy names are dead declarations. The comment incorrectly identifies the consumer and misleads future maintainers about why these stubs exist.

⚠️ Suggestions

• src/compile/extensions/ado_script.rs (~line 217–228) — duplicated doc-comment. The "Outputs declared by the synthPr step" paragraph appears twice back-to-back (copy-paste artifact).

• src/compile/ir/lower.rs (lower_env_value_as_expr_atom for Coalesce) — comment says "Flatten nested Coalesce: their children appear inline in the enclosing one's argument list" but the code actually produces a nested coalesce(...) call string, not a flattened list. Functionally correct since ADO handles nested coalesce, but the comment contradicts the implementation.

✅ What Looks Good

• Condition::Custom injection check correctly rejects ##vso[ / ##[ pipeline commands and embedded newlines while intentionally passing ${{...}} ADO template expressions.
• lower_outputref's expect("cross-stage ref must have producer stage") is load-bearing and protected: add_edge_for_ref returns bail! for mixed staged/un-staged references before this path is reachable.
• Kahn-based detect_cycles_in is correct; the expect("node must be in in_degree") is sound because adjacency-map consumers are unconditionally inserted into in_degree in the same loop.
• Single-item Coalesce in agent_job_variables_hoist correctly appends '' sentinel, producing $[ coalesce(dependencies.Setup.outputs['synthPr.AW_PR_ID'], '') ].
• ALLOWED_ADO_MACROS allowlist in env.rs is a clean compile-time guard against silent $(BadVar) literal passthrough.

Generated by Rust PR Reviewer for issue #960 · sonnet46 4.1M · ◷

[github-actions]

🔍 Rust PR Review

Summary: Looks good — well-structured IR with thorough validation and test coverage. Two minor concerns around expect() usage and one style note.

Findings

⚠️ Suggestions

• src/compile/ir/output.rs:156 — lower_outputref returns String (not Result<String>) but contains an .expect() for the cross-stage/no-producer-stage case. The graph validation in add_edge_for_ref does bail on mixed staged/un-staged references before lowering, so this is safe along the normal resolve() → lower() path. But it's a silent panic if lower_outputref is ever called outside that flow. The comment says "graph validation enforces" but the function signature doesn't type-encode that precondition. Consider returning Result<String> for defensive consistency; alternatively document the precondition as a # Safety-style doc comment to make the invariant explicit.

• src/compile/standalone_ir.rs:1171–1175 — wire_explicit_dependencies uses four consecutive .expect() calls on prefix.id(...). The invariant (prefix is valid because the jobs were built successfully with the same prefix) holds in the current call graph, but the function signature fn wire_explicit_dependencies(jobs: &mut [Job], prefix: &JobPrefix<'_>) doesn't capture it — it could be called from a context where that invariant doesn't hold. Changing to -> Result<()> and using ? would eliminate the latent panic risk with minimal noise.

• src/compile/extensions/mod.rs:157 — #[allow(dead_code)] is placed on the entire Declarations struct. Several fields (detection_prepare_steps, safe_outputs_steps, agent_finalize_steps, agent_finalize_condition) are declared but never read in standalone_ir.rs. A struct-level suppression means any future unused field will silently escape the lint. Prefer per-field annotations on the specific unimplemented fields, or add // TODO(#NNN) comments so they're tracked rather than silently dead.

✅ What Looks Good

• Injection defences are correct: Condition::Custom validation rejects both ##vso[/##[ pipeline commands and embedded newlines before codegen. ALLOWED_ADO_MACROS allowlist prevents silent typo-expansion at pipeline runtime. lower_raw_yaml round-trips user-authored YAML through serde_yaml::from_str before emitting, so malformed YAML surfaces as a compile error rather than a corrupt pipeline file.
• Graph validation is thorough: add_edge_for_ref explicitly bails on mixed staged/un-staged OutputRefs; detect_cycles_in (Kahn's algorithm) uses BTreeSet edges so there's no duplicate-edge double-counting, and the .expect("node must be in in_degree") invariant is provably safe because every successor in the adjacency map is also a consumer in the in-degree map.
• EnvValue::Concat inside Coalesce returns a runtime error, not a panic — the bail path in lower_env_value_as_expr_atom correctly rejects this at IR-lower time with an actionable message.
• apply_auto_is_output only touches Step::Bash — TaskStep has no outputs field so the pattern match is exhaustive by design, and collect_step_outputs documents the expected extension point for when TaskStep gains outputs.
• Test coverage throughout — condition.rs, env.rs, ids.rs, output.rs, graph.rs, lower.rs, and emit.rs all have #[cfg(test)] suites covering happy paths and every error variant that matters.

Generated by Rust PR Reviewer for issue #960 · sonnet46 4.4M · ◷