devflow-engine 1.0.0__py3-none-any.whl

devflow_engine/prompts/integration/red/example.md

@@ -0,0 +1,152 @@
+# Red node assembled payloads
+
+## Provenance
+
+Reconstructed from:
+
+- `prompts/integration/red/red/prompt.md`
+- `prompts/integration/red/red_repair/prompt.md`
+- `prompts/integration/red/code_repair/prompt.md`
+- `src/devflow_engine/integration/dag.py` red generation / repair / re-generation calls
+- `src/devflow_engine/agentic_runtime.py`
+- `RedArtifact` and `CodeRepairArtifact` in `src/devflow_engine/integration/dag.py`
+
+Not copied from a persisted past-run integration prompt.
+
+## Stable doctrine vs actual payload
+
+- Stable node doctrine file: `prompts/integration/red/node_config/prompt.md`
+- Actual `instructions` come from stage prompt markdown; repair mode also gets a runtime-appended iteration line
+- Actual `context` comes from validation outputs, workflow artifacts, and repair selections in `integration/dag.py`
+- No skills or tools are injected here
+
+## Assembled payload: `integration_red`
+
+```json
+{
+  "task": "integration_red",
+  "instructions": [
+    "Emit exactly one red package per validated workflow.",
+    "Anchor each package to the workflow's side effect and the strongest real interaction point.",
+    "Use only these harness_kind values: playwright, endpoint_harness, cli_harness, artifact_probe, background_observer, integration_harness.",
+    "Use integration_harness only when no concrete interaction point kind fits.",
+    "If a required interaction point is missing, keep the package failing and make the gap explicit in harness_selection.gap_explicit and gap_notes.",
+    "Failing artifacts and assertions must prove the side effect, not implementation trivia.",
+    "Return JSON only."
+  ],
+  "context": {
+    "idea_id": "idea_checkout_recovery_v1",
+    "validated_workflows": [
+      {
+        "workflow_id": "wf_recovery_email_sent",
+        "side_effect": { "id": "se_recovery_email_sent", "name": "Recovery email sent" },
+        "interaction_points": [
+          { "kind": "endpoint", "name": "POST /api/carts/{cart_id}/recover", "implemented": true }
+        ]
+      }
+    ],
+    "validation_report": { "passed": true, "errors": [] },
+    "side_effects_artifact": { "idea_id": "idea_checkout_recovery_v1", "side_effects": [{ "id": "se_recovery_email_sent" }] },
+    "implicated_users_artifact": { "idea_id": "idea_checkout_recovery_v1", "implicated_users": [{ "kind": "human", "scope": "customer_account", "authority": "self", "rationale": "customer receives reminder" }], "denied_candidates": [] },
+    "code_evidence": [
+      { "path": "src/jobs/recovery_email_job.py", "side_effect_ids": [], "interaction_points": [] }
+    ]
+  },
+  "output_schema": "RedArtifact.model_json_schema()",
+  "return_format": "json_only"
+}
+```
+
+## Assembled payload: `integration_code_repair_iter1` (red repair mode)
+
+```json
+{
+  "task": "integration_code_repair_iter1",
+  "instructions": [
+    "Patch the smallest real code change that fixes the current failing workflow surface.",
+    "Choose one primary failing seam from validation_errors, failing_packages, failing_workflows, and code_evidence; keep edits there unless the same failure forces one adjacent file.",
+    "Prefer files already named by the failing workflow, package interaction point, or code evidence.",
+    "Update updated_workflows only when the repaired code changes workflow truth.",
+    "Do not repair proof-package artifacts here. Do not edit engine, runtime, orchestration, or prompt-loading layers unless the failure explicitly originates there.",
+    "If the failure is artifact-only, harness-only, or runtime-only, leave code unchanged and explain it in unresolvable_failures.",
+    "Return only changed files with full contents, updated_workflows, and unresolvable_failures.",
+    "This is repair iteration 1. Stay on the current failing seam. Do not revisit clean surfaces.",
+    "Return JSON only."
+  ],
+  "context": {
+    "failing_packages": [
+      {
+        "workflow_id": "wf_recovery_email_sent",
+        "side_effect_id": "se_recovery_email_sent",
+        "status": "failing",
+        "harness_selection": {
+          "harness_kind": "integration_harness",
+          "interaction_point_ref": "POST /api/carts/{cart_id}/recover",
+          "interaction_point_kind": "endpoint",
+          "rationale": "placeholder harness selection",
+          "gap_explicit": false
+        },
+        "failing_artifacts": [],
+        "expected_assertions": [],
+        "implicated_user_routes": [],
+        "gap_notes": []
+      }
+    ],
+    "validation_errors": [
+      "red harness mismatch for wf_recovery_email_sent: expected endpoint_harness"
+    ],
+    "failing_workflows": [
+      {
+        "workflow_id": "wf_recovery_email_sent",
+        "interaction_points": [
+          { "kind": "endpoint", "name": "POST /api/carts/{cart_id}/recover", "implemented": true }
+        ]
+      }
+    ],
+    "side_effects_artifact": { "idea_id": "idea_checkout_recovery_v1", "side_effects": [{ "id": "se_recovery_email_sent" }] },
+    "implicated_users_artifact": { "idea_id": "idea_checkout_recovery_v1", "implicated_users": [{ "kind": "human", "scope": "customer_account", "authority": "self", "rationale": "customer receives reminder" }], "denied_candidates": [] },
+    "code_evidence": [
+      { "path": "src/jobs/recovery_email_job.py", "side_effect_ids": [], "interaction_points": [] }
+    ]
+  },
+  "output_schema": "CodeRepairArtifact.model_json_schema()",
+  "return_format": "json_only"
+}
+```
+
+## Assembled payload: `integration_red_repair_iter1`
+
+```json
+{
+  "task": "integration_red_repair_iter1",
+  "instructions": [
+    "Repair the current failing package surface with the smallest package delta.",
+    "Keep each package anchored to the same workflow side effect and the strongest supported interaction point.",
+    "Treat the package's current failing interaction point as the primary seam; if none is credible, make the gap explicit instead of broadening the package.",
+    "Do not revisit passing packages, settled claims, or unrelated workflows.",
+    "Do not turn artifact repair into product-code repair or runtime repair.",
+    "Keep missing interaction-point gaps explicit instead of implying passability.",
+    "Failing artifacts and assertions must still prove the side effect, not implementation trivia.",
+    "Return JSON only."
+  ],
+  "context": {
+    "idea_id": "idea_checkout_recovery_v1",
+    "validated_workflows": [
+      {
+        "workflow_id": "wf_recovery_email_sent",
+        "interaction_points": [
+          { "kind": "endpoint", "name": "POST /api/carts/{cart_id}/recover", "implemented": true }
+        ]
+      }
+    ],
+    "validation_report": { "passed": true, "errors": [] },
+    "side_effects_artifact": { "idea_id": "idea_checkout_recovery_v1", "side_effects": [{ "id": "se_recovery_email_sent" }] },
+    "implicated_users_artifact": { "idea_id": "idea_checkout_recovery_v1", "implicated_users": [{ "kind": "human", "scope": "customer_account", "authority": "self", "rationale": "customer receives reminder" }], "denied_candidates": [] },
+    "code_evidence": [
+      { "path": "src/jobs/recovery_email_job.py", "side_effect_ids": [], "interaction_points": [] }
+    ]
+  },
+  "output_schema": "RedArtifact.model_json_schema()",
+  "return_format": "json_only"
+}
+```

devflow_engine/prompts/integration/red/node_config/prompt.md

@@ -0,0 +1,86 @@
+# Red Node Contract
+
+Generate failing integration proof packages for the validated workflows.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("red")`
+- `RedNode.get_agent_config()`
+
+## What actually reaches the model
+
+The current runtime uses three red-related model payloads:
+
+1. red generation pass (`integration_red`)
+2. red code repair pass (`integration_code_repair_iter<N>` when red mode is active)
+3. red re-generation pass (`integration_red_repair_iter<N>`)
+
+## Real injected runtime components
+
+### Red generation pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← `task_context.metadata["workflows"]`
+- `validation_report` ← `task_context.metadata["validation_report"]`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/red/prompt.md`
+
+`output_schema` source:
+
+- `RedArtifact.model_json_schema()`
+
+### Red code repair pass
+
+`context_payload` fields:
+
+- `failing_packages` ← selected from invalid red packages
+- `validation_errors` ← `report["errors"]`
+- `failing_workflows` ← workflows matching failing packages
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/code_repair/prompt.md`
+- plus runtime-appended line: `This is repair iteration <N>. Stay on the current failing seam. Do not revisit clean surfaces.`
+
+`output_schema` source:
+
+- `CodeRepairArtifact.model_json_schema()`
+
+Current runtime does not inject explicit `likely_next_seam`, `do_not_revisit`, or allowed-edit-root fields; repair must infer focus from the failing packages, failing workflows, and provided evidence.
+
+### Red re-generation pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← failing workflows only
+- `validation_report` ← `task_context.metadata["validation_report"]`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/red_repair/prompt.md`
+
+`output_schema` source:
+
+- `RedArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- Repair operates by returning full-file patches in JSON, not by model tool calls.

devflow_engine/prompts/integration/red/past_prompts/20260417T212300/code_repair/prompt.md

@@ -0,0 +1,19 @@
+# Red Code Repair
+
+You are the Integration Code Repair agent. Validation failed. Repair the code so it passes.
+
+- This is a real GenAI DAG. Return JSON only.
+- Node 1 and Node 2 must be genuinely model-backed; do not simulate agentic behavior with deterministic shortcuts.
+- Workflows are anchored to side effects, not users.
+- Attach implicated users to workflows using the canonical actor model: kind x scope x authority.
+- Reject denied canonical actor combinations by listing them under denied_candidates with explicit reasons.
+- Treat interaction points as first-class. Reference implemented seams when they exist; mark needed interaction points when required but missing.
+- Preserve alignment to implemented stories, implementation evidence, and source docs.
+- Do not overclaim unsupported implementation. Keep rationale explicit.
+- You are the Integration Code Repair agent. Validation failed. Repair the code so it passes.
+- For MISSING_INTERACTION_POINTS: inspect the code evidence for the side effect, find or create the actual seam interfaces, write the code. Declare the interaction_points in the updated workflow.
+- For STORY_ALIGNMENT_MISMATCH: inspect the code evidence against the story contract. Patch the code so it satisfies the story intent. Update the workflow to correctly describe the implementation.
+- For MISSING_CODE_BACKING: implement the missing code seam for the side effect. Write real implementation code, not stubs.
+- Write only the files that need to change. Return full file content for each patched file.
+- Return updated_workflows with corrected interaction_points and story_backing for every workflow you repaired.
+- In unresolvable_failures list any failure you cannot fix with code changes (e.g. fundamentally undefined story contract).

devflow_engine/prompts/integration/red/past_prompts/20260417T212300/node_config/prompt.md

@@ -0,0 +1,84 @@
+# Red Node Contract
+
+Red is a real GenAI node: generate failing integration proof artifacts anchored to validated workflows and real interaction points.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("red")`
+- `RedNode.get_agent_config()`
+
+## What actually reaches the model
+
+The current runtime uses three red-related model payloads:
+
+1. red generation pass (`integration_red`)
+2. red code repair pass (`integration_code_repair_iter<N>` when red mode is active)
+3. red re-generation pass (`integration_red_repair_iter<N>`)
+
+## Real injected runtime components
+
+### Red generation pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← `task_context.metadata["workflows"]`
+- `validation_report` ← `task_context.metadata["validation_report"]`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/red/prompt.md`
+
+`output_schema` source:
+
+- `RedArtifact.model_json_schema()`
+
+### Red code repair pass
+
+`context_payload` fields:
+
+- `failing_packages` ← selected from invalid red packages
+- `validation_errors` ← `report["errors"]`
+- `failing_workflows` ← workflows matching failing packages
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/code_repair/prompt.md`
+- plus runtime-appended repair-iteration line
+
+`output_schema` source:
+
+- `CodeRepairArtifact.model_json_schema()`
+
+### Red re-generation pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← failing workflows only
+- `validation_report` ← `task_context.metadata["validation_report"]`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/red_repair/prompt.md`
+
+`output_schema` source:
+
+- `RedArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- Repair operates by returning full-file patches in JSON, not by model tool calls.

devflow_engine/prompts/integration/red/past_prompts/20260417T212300/red/prompt.md

@@ -0,0 +1,16 @@
+# Red
+
+Red is a real GenAI node: generate failing integration proof artifacts anchored to validated workflows and real interaction points.
+
+- This is a real GenAI DAG. Return JSON only.
+- Node 1 and Node 2 must be genuinely model-backed; do not simulate agentic behavior with deterministic shortcuts.
+- Workflows are anchored to side effects, not users.
+- Attach implicated users to workflows using the canonical actor model: kind x scope x authority.
+- Reject denied canonical actor combinations by listing them under denied_candidates with explicit reasons.
+- Treat interaction points as first-class. Reference implemented seams when they exist; mark needed interaction points when required but missing.
+- Preserve alignment to implemented stories, implementation evidence, and source docs.
+- Do not overclaim unsupported implementation. Keep rationale explicit.
+- Emit one red package per validated workflow.
+- Choose harnesses from the real interaction points. Use ONLY these canonical harness_kind values: playwright (UI), endpoint_harness (API/HTTP/REST/GraphQL/health-check/webhook endpoints), cli_harness (CLI), artifact_probe (file artifacts), background_observer (background jobs/events/queues). Use integration_harness only when no interaction point kind is recognizable.
+- If only needed/missing interaction points exist, keep the package failing and make the gap explicit in harness_selection.gap_explicit and gap_notes.
+- Failing artifacts must prove side effects, not implementation trivia.

devflow_engine/prompts/integration/red/past_prompts/20260417T212300/red_repair/prompt.md

@@ -0,0 +1,15 @@
+# Red Repair
+
+Red is a real GenAI node: generate failing integration proof artifacts anchored to validated workflows and real interaction points.
+
+- This is a real GenAI DAG. Return JSON only.
+- Node 1 and Node 2 must be genuinely model-backed; do not simulate agentic behavior with deterministic shortcuts.
+- Workflows are anchored to side effects, not users.
+- Attach implicated users to workflows using the canonical actor model: kind x scope x authority.
+- Reject denied canonical actor combinations by listing them under denied_candidates with explicit reasons.
+- Treat interaction points as first-class. Reference implemented seams when they exist; mark needed interaction points when required but missing.
+- Preserve alignment to implemented stories, implementation evidence, and source docs.
+- Do not overclaim unsupported implementation. Keep rationale explicit.
+- Emit one red package per validated workflow.
+- Choose harnesses from the real interaction points. Use ONLY these canonical harness_kind values: playwright, endpoint_harness, cli_harness, artifact_probe, background_observer, integration_harness.
+- This is a repair re-generation pass.

devflow_engine/prompts/integration/red/past_prompts/20260417T215032/code_repair/prompt.md

@@ -0,0 +1,10 @@
+# Red Code Repair
+
+Repair the code so the listed failing workflows can pass validation.
+
+- Use validation_errors and the provided code evidence to identify the minimal real code changes.
+- For MISSING_INTERACTION_POINTS, create or declare the real seam and update interaction_points in the repaired workflow.
+- For STORY_ALIGNMENT_MISMATCH, patch the code and workflow description to match supported story intent.
+- For MISSING_CODE_BACKING, implement the missing seam with real code, not stubs.
+- Return only changed files with full contents, updated_workflows for repaired workflows, and unresolvable_failures for anything code cannot fix.
+- Return JSON only.

devflow_engine/prompts/integration/red/past_prompts/20260417T215032/node_config/prompt.md

@@ -0,0 +1,84 @@
+# Red Node Contract
+
+Generate failing integration proof packages for the validated workflows.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("red")`
+- `RedNode.get_agent_config()`
+
+## What actually reaches the model
+
+The current runtime uses three red-related model payloads:
+
+1. red generation pass (`integration_red`)
+2. red code repair pass (`integration_code_repair_iter<N>` when red mode is active)
+3. red re-generation pass (`integration_red_repair_iter<N>`)
+
+## Real injected runtime components
+
+### Red generation pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← `task_context.metadata["workflows"]`
+- `validation_report` ← `task_context.metadata["validation_report"]`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/red/prompt.md`
+
+`output_schema` source:
+
+- `RedArtifact.model_json_schema()`
+
+### Red code repair pass
+
+`context_payload` fields:
+
+- `failing_packages` ← selected from invalid red packages
+- `validation_errors` ← `report["errors"]`
+- `failing_workflows` ← workflows matching failing packages
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/code_repair/prompt.md`
+- plus runtime-appended repair-iteration line
+
+`output_schema` source:
+
+- `CodeRepairArtifact.model_json_schema()`
+
+### Red re-generation pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← failing workflows only
+- `validation_report` ← `task_context.metadata["validation_report"]`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `code_evidence` ← `event.code_evidence`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red/red_repair/prompt.md`
+
+`output_schema` source:
+
+- `RedArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- Repair operates by returning full-file patches in JSON, not by model tool calls.

devflow_engine/prompts/integration/red/past_prompts/20260417T215032/red_repair/prompt.md

@@ -0,0 +1,11 @@
+# Red Repair
+
+Re-generate failing integration proof packages for repaired workflows.
+
+- Emit exactly one red package per validated workflow.
+- Anchor each package to the workflow's side effect and the strongest real interaction point.
+- Use only these harness_kind values: playwright, endpoint_harness, cli_harness, artifact_probe, background_observer, integration_harness.
+- Use integration_harness only when no concrete interaction point kind fits.
+- Keep missing interaction-point gaps explicit instead of implying passability.
+- Failing artifacts and assertions must still prove the side effect, not implementation trivia.
+- Return JSON only.

devflow_engine/prompts/integration/red/red/prompt.md

@@ -0,0 +1,11 @@
+# Red
+
+Generate failing integration proof packages for the validated workflows.
+
+- Emit exactly one red package per validated workflow.
+- Anchor each package to the workflow's side effect and the strongest real interaction point.
+- Use only these harness_kind values: playwright, endpoint_harness, cli_harness, artifact_probe, background_observer, integration_harness.
+- Use integration_harness only when no concrete interaction point kind fits.
+- If a required interaction point is missing, keep the package failing and make the gap explicit in harness_selection.gap_explicit and gap_notes.
+- Failing artifacts and assertions must prove the side effect, not implementation trivia.
+- Return JSON only.

devflow_engine/prompts/integration/red/red_repair/prompt.md

@@ -0,0 +1,12 @@
+# Red Repair
+
+Re-generate only the failing red proof packages.
+
+- Repair the current failing package surface with the smallest package delta.
+- Keep each package anchored to the same workflow side effect and the strongest supported interaction point.
+- Treat the package's current failing interaction point as the primary seam; if none is credible, make the gap explicit instead of broadening the package.
+- Do not revisit passing packages, settled claims, or unrelated workflows.
+- Do not turn artifact repair into product-code repair or runtime repair.
+- Keep missing interaction-point gaps explicit instead of implying passability.
+- Failing artifacts and assertions must still prove the side effect, not implementation trivia.
+- Return JSON only.

devflow_engine/prompts/integration/red_review/example.md

@@ -0,0 +1,71 @@
+# Red Review node assembled payload
+
+## Provenance
+
+Reconstructed from:
+
+- `prompts/integration/red_review/red_review/prompt.md`
+- `src/devflow_engine/integration/dag.py` red review agent call
+- `src/devflow_engine/agentic_runtime.py`
+- `RedReviewArtifact` in `src/devflow_engine/integration/dag.py`
+
+Not copied from a persisted past-run integration prompt.
+
+## Stable doctrine vs actual payload
+
+- Stable node doctrine file: `prompts/integration/red_review/node_config/prompt.md`
+- Actual `instructions` come from `red_review/red_review/prompt.md`
+- Actual `context` comes from `task_context.metadata` + `event.idea_id`
+- No skills or tools are injected here
+
+```json
+{
+  "task": "integration_red_review",
+  "instructions": [
+    "Review every red package against its workflow and side effect.",
+    "Find overreach, under-assertion, weak interaction-point anchoring, and missing actor-route coverage.",
+    "Return reviewed_packages plus findings and repair_directions per workflow.",
+    "Keep critiques evidence-based; do not invent unsupported failures.",
+    "Return JSON only."
+  ],
+  "context": {
+    "idea_id": "idea_checkout_recovery_v1",
+    "validated_workflows": [
+      {
+        "workflow_id": "wf_recovery_email_sent",
+        "side_effect": { "id": "se_recovery_email_sent", "name": "Recovery email sent" },
+        "interaction_points": [
+          { "kind": "endpoint", "name": "POST /api/carts/{cart_id}/recover", "implemented": true }
+        ]
+      }
+    ],
+    "red_artifact": {
+      "idea_id": "idea_checkout_recovery_v1",
+      "summary": "Generated one failing package.",
+      "packages": [
+        {
+          "workflow_id": "wf_recovery_email_sent",
+          "side_effect_id": "se_recovery_email_sent",
+          "status": "failing",
+          "harness_selection": {
+            "harness_kind": "endpoint_harness",
+            "interaction_point_ref": "POST /api/carts/{cart_id}/recover",
+            "interaction_point_kind": "endpoint",
+            "rationale": "Workflow is entered through an API endpoint.",
+            "gap_explicit": false
+          },
+          "failing_artifacts": [],
+          "expected_assertions": [
+            { "assertion_id": "assert_response_accepted", "summary": "response indicates recovery request accepted", "evidence_anchor": "HTTP 202" }
+          ],
+          "implicated_user_routes": [],
+          "gap_notes": []
+        }
+      ]
+    },
+    "validation_report": { "passed": true, "errors": [] }
+  },
+  "output_schema": "RedReviewArtifact.model_json_schema()",
+  "return_format": "json_only"
+}
+```

devflow_engine/prompts/integration/red_review/node_config/prompt.md

@@ -0,0 +1,41 @@
+# Red Review Node Contract
+
+Review red integration proof packages for alignment, adequacy, and coverage.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("red_review")`
+- `RedReviewNode.get_agent_config()`
+
+## What actually reaches the model
+
+The model-facing payload is assembled from:
+
+- stage bullets in `prompts/integration/red_review/red_review/prompt.md`
+- runtime `context_payload` from `src/devflow_engine/integration/dag.py`
+- `RedReviewArtifact.model_json_schema()`
+- `return_format: "json_only"`
+
+## Real injected runtime components
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← `task_context.metadata["workflows"]`
+- `red_artifact` ← `task_context.metadata["red_artifact"]`
+- `validation_report` ← `task_context.metadata["validation_report"]`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red_review/red_review/prompt.md`
+
+`output_schema` source:
+
+- `RedReviewArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.

devflow_engine/prompts/integration/red_review/past_prompts/20260417T212300/node_config/prompt.md

@@ -0,0 +1,41 @@
+# Red Review Node Contract
+
+RedReview is a real GenAI node: critique red integration proofs for alignment, adequacy, and workflow-side-effect coverage.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("red_review")`
+- `RedReviewNode.get_agent_config()`
+
+## What actually reaches the model
+
+The model-facing payload is assembled from:
+
+- stage bullets in `prompts/integration/red_review/red_review/prompt.md`
+- runtime `context_payload` from `src/devflow_engine/integration/dag.py`
+- `RedReviewArtifact.model_json_schema()`
+- `return_format: "json_only"`
+
+## Real injected runtime components
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `validated_workflows` ← `task_context.metadata["workflows"]`
+- `red_artifact` ← `task_context.metadata["red_artifact"]`
+- `validation_report` ← `task_context.metadata["validation_report"]`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/red_review/red_review/prompt.md`
+
+`output_schema` source:
+
+- `RedReviewArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.