Summary

• Problem: When a when: condition references $nodeId.output.field and the node output is not valid JSON (e.g. Pi/Minimax wrapping JSON in markdown fences or prepending reasoning prose), the condition evaluator returns parsed: true with result: false. The DAG executor treats this as a legitimate "condition not met" skip. The workflow exits 0 — no error, no review posted, silent failure.
• Why it matters: A 5-minute workflow "succeeds" without doing the work. Users have no way to detect the failure from the CLI exit code. This violates the "Fail Fast + Explicit Errors" principle. Observed in ~17% of maintainer-review-pr runs with Pi.
• What changed: resolveOutputRef() now throws OutputRefParseError when JSON parse fails (instead of returning empty string). evaluateAtom() catches it and returns {parsed: false}. Also strips common markdown fences (\x60\x60\x60json blocks) before attempting JSON.parse.
• What did not change (scope boundary): No changes to dag-executor.ts — it already correctly handles parsed: false (surfaces error message, logs properly, exits non-zero). No changes to structuredOutput paths — they are unaffected since the JSON parse fallback is only reached when structured output is absent.

UX Journey

Before

User                       Archon                       Pi
────                       ──────                       ──
runs maintainer-review-pr ▶ executes gate node ────────▶ returns "Let me think...\n\x60\x60\x60json\n{...}\n\x60\x60\x60"
                            condition_json_parse_failed (warn log only)
                            $gate.output.verdict == 'review' → false (parsed: true)
                            every downstream node → Skipped (when_condition)
sees "Workflow completed   ◀── exit 0, no review posted
successfully" (WRONG)

After

User                       Archon                       Pi
────                       ──────                       ──
runs maintainer-review-pr ▶ executes gate node ────────▶ returns "Let me think...\n\x60\x60\x60json\n{...}\n\x60\x60\x60"
                            strips markdown fences ✓
                            JSON.parse succeeds ✓
                            $gate.output.verdict == 'review' → true
                            downstream nodes execute normally ✓
sees review posted         ◀── exit 0, review posted (CORRECT)

--- If JSON is truly unparseable (no fences, just prose): ---

runs maintainer-review-pr ▶ executes gate node ────────▶ returns "Sure, here is my analysis..."
                            fence strip: no fences found
                            JSON.parse fails
                            condition_json_parse_failed (warn log)
                            resolveOutputRef throws OutputRefParseError
                            evaluateAtom returns {parsed: false}
sees "⚠️ Node 'gate':  ◀── exit non-zero, error surfaced (CORRECT)
unparseable when: ..."

Architecture Diagram

Before

evaluateAtom → resolveOutputRef → JSON.parse fails → returns ""
     ↓                                                    ↓
  actual="" vs expected="review" → {result: false, parsed: true}
     ↓
  DAG: legitimate skip → exit 0  ← WRONG

After

evaluateAtom → resolveOutputRef → strip fences → JSON.parse
     ↓                                              ↓ success → return value
     ↓                                              ↓ fail → throw OutputRefParseError
  catch OutputRefParseError → {result: false, parsed: false}
     ↓
  DAG: when_condition_parse_error → surface message → exit non-zero  ← CORRECT

Connection inventory:

Label Snapshot

• Risk: risk: low
• Size: size: S
• Scope: workflows
• Module: workflows:condition-evaluator

Change Metadata

• Change type: bug
• Primary scope: workflows

Linked Issue

• Closes Workflow exits success when condition_json_parse_failed cascades to silent node skips #1673

Validation Evidence (required)

bun run test    # 54 pass, 0 fail (condition-evaluator.test.ts)
bun run type-check  # all 5 packages pass
# lint-staged ran eslint + prettier on commit

• Evidence provided: All 54 condition evaluator tests pass, including 4 new tests for the fix.
• If any command is intentionally skipped: bun run format:check covered by lint-staged on commit.

Security Impact (required)

• New permissions/capabilities? No
• New external network calls? No
• Secrets/tokens handling changed? No
• File system access scope changed? No

Compatibility / Migration

• Backward compatible? Partially — workflows that previously "succeeded silently" will now surface an error and exit non-zero. This is the intended fix; the silent success was a bug.
• Config/env changes? No
• Database migration needed? No

Human Verification (required)

• Verified scenarios: (1) Invalid JSON output → parsed:false returned (2) Markdown-fenced JSON → fences stripped, parsed correctly (3) Compound AND with one unparseable atom → parsed:false propagates (4) All 50 existing tests still pass (no regressions)
• Edge cases checked: Plain \x60\x60\x60 fences (no language tag), prose before/after fences, multiple fence blocks (first match used)
• What was not verified: Live Pi/Minimax output (no access to those providers locally)

Side Effects / Blast Radius (required)

• Affected subsystems/workflows: Any workflow with when: clauses referencing $node.output.field where the producing node is an LLM
• Potential unintended effects: Workflows that relied on the silent-skip behavior will now error out. This is correct — the silent skip was masking failures.
• Guardrails/monitoring: The condition_json_parse_failed warn log already exists; the new behavior just escalates it from "silent skip" to "error + exit non-zero"

Rollback Plan (required)

• Fast rollback command/path: Revert the commit (single file change)
• Feature flags or config toggles: None needed — the change is in the condition evaluator return contract
• Observable failure symptoms: Workflows that previously "completed successfully" with skipped nodes will now show when_condition_parse_error messages

Risks and Mitigations

• Risk: Workflows with noisy LLM outputs may fail more frequently
  • Mitigation: The fence-stripping logic handles the most common Pi/Minimax pattern. For truly unparseable output, the correct behavior IS to fail and retry, not to silently skip.

Summary by CodeRabbit

• Bug Fixes

  • Improved error handling for JSON parsing failures in condition evaluation, ensuring errors are properly reported rather than silently ignored.
  • Added support for JSON values wrapped in markdown code fences.
  • Enhanced error propagation through compound conditions when JSON parsing fails.

• Tests

  • Added test coverage for JSON parsing failures and markdown code fence handling in condition evaluation.