devflow-engine 1.0.0__py3-none-any.whl

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

@@ -0,0 +1,67 @@
+# Validate Node Contract
+
+Enrich and repair integration workflows to ensure they have complete story backing, code backing, and interaction point coverage before the deterministic gate.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("validate")`
+- `ValidateEnrichGateNode.get_agent_config()`
+
+## What actually reaches the model
+
+The current integration runtime uses two validate-node prompt shapes:
+
+1. enrich/validate pass (`integration_validate_enrich_gate`)
+2. code repair pass (`integration_code_repair_iter<N>`)
+
+Those model-facing payloads are assembled from stage bullets + runtime context + output schema.
+
+## Real injected runtime components
+
+### Validate enrich pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `workflows` ← `task_context.metadata["workflows"]`
+- `implemented_stories` ← `event.implemented_stories`
+- `code_evidence` ← `event.code_evidence`
+- `source_docs` ← `event.source_docs`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/validate/validate_enrich_gate/prompt.md`
+
+`output_schema` source:
+
+- `ValidateEnrichArtifact.model_json_schema()`
+
+### Validate code repair pass
+
+`context_payload` fields:
+
+- `failing_workflows` ← derived from validation failures against `enriched_workflows`
+- `validation_errors` ← `report["errors"]`
+- `code_evidence_files` ← `_load_code_evidence_for_workflows(...)`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `implemented_stories` ← `event.implemented_stories`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/validate/code_repair/prompt.md`
+- plus runtime-appended line: `This is repair iteration <N>. Be precise and targeted.`
+
+`output_schema` source:
+
+- `CodeRepairArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- File content reaches repair through `code_evidence_files`, not through an interactive tool surface.

devflow_engine/prompts/integration/validate/past_prompts/20260417T212300/validate_enrich_gate/prompt.md

@@ -0,0 +1,17 @@
+# Validate Enrich Gate
+
+Enrich and repair integration workflows to ensure they have complete story backing, code backing, and interaction point coverage before the deterministic gate.
+
+- 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.
+- Review every workflow using the real model-backed runtime path and return enriched_workflows plus findings.
+- You may enrich rationale, story/code/source-doc backing, process sequencing clarity, branches, resulting artifacts, and interaction-point descriptions when the evidence supports it.
+- Do not invent unsupported seams, actor coverage, or implementation facts.
+- Keep blocking findings explicit when a workflow is under-supported, inconsistent, or overclaims coverage.
+- Preserve workflow identity and side-effect anchoring; return exactly one enriched workflow per input workflow.

devflow_engine/prompts/integration/validate/past_prompts/20260417T212300/validate_repair/prompt.md

@@ -0,0 +1,16 @@
+# Validate Repair
+
+Enrich and repair integration workflows to ensure they have complete story backing, code backing, and interaction point coverage before the deterministic gate.
+
+- 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 performing a repair pass on the enriched_workflows.
+- Resolve every repair source listed in repair_sources, including deterministic validation errors and blocking agentic findings.
+- Use deterministic_errors for structural/deterministic validation failures and blocking_findings for agentic blocking findings.
+- Return enriched_workflows with the same workflow_ids; do not add or remove workflows.

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

@@ -0,0 +1,10 @@
+# Validate 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/validate/past_prompts/20260417T215032/node_config/prompt.md

@@ -0,0 +1,67 @@
+# Validate Node Contract
+
+Enrich and repair workflows so they are evidence-backed and structurally ready for deterministic validation.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("validate")`
+- `ValidateEnrichGateNode.get_agent_config()`
+
+## What actually reaches the model
+
+The current integration runtime uses two validate-node prompt shapes:
+
+1. enrich/validate pass (`integration_validate_enrich_gate`)
+2. code repair pass (`integration_code_repair_iter<N>`)
+
+Those model-facing payloads are assembled from stage bullets + runtime context + output schema.
+
+## Real injected runtime components
+
+### Validate enrich pass
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `workflows` ← `task_context.metadata["workflows"]`
+- `implemented_stories` ← `event.implemented_stories`
+- `code_evidence` ← `event.code_evidence`
+- `source_docs` ← `event.source_docs`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/validate/validate_enrich_gate/prompt.md`
+
+`output_schema` source:
+
+- `ValidateEnrichArtifact.model_json_schema()`
+
+### Validate code repair pass
+
+`context_payload` fields:
+
+- `failing_workflows` ← derived from validation failures against `enriched_workflows`
+- `validation_errors` ← `report["errors"]`
+- `code_evidence_files` ← `_load_code_evidence_for_workflows(...)`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `implemented_stories` ← `event.implemented_stories`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/validate/code_repair/prompt.md`
+- plus runtime-appended line: `This is repair iteration <N>. Be precise and targeted.`
+
+`output_schema` source:
+
+- `CodeRepairArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- File content reaches repair through `code_evidence_files`, not through an interactive tool surface.

devflow_engine/prompts/integration/validate/past_prompts/20260417T215032/validate_repair/prompt.md

@@ -0,0 +1,9 @@
+# Validate Repair
+
+Repair enriched workflows so they are structurally ready for deterministic validation.
+
+- Resolve every repair source listed in repair_sources.
+- Use deterministic_errors for structural failures and blocking_findings for agentic blocking findings.
+- Return enriched_workflows with the same workflow_ids.
+- Repair unsupported claims, missing backing, and missing interaction points without inventing evidence.
+- Return JSON only.

devflow_engine/prompts/integration/validate/validate_enrich_gate/prompt.md

@@ -0,0 +1,10 @@
+# Validate Enrich Gate
+
+Enrich workflows so they are evidence-backed and ready for deterministic validation.
+
+- Review every workflow and return exactly one enriched_workflow per input workflow.
+- Preserve workflow identity and side-effect anchoring.
+- Improve rationale, backing, sequencing, branches, resulting artifacts, and interaction-point descriptions only where the evidence supports it.
+- Make unsupported, inconsistent, or under-supported areas explicit in findings.
+- Do not invent seams, actors, or implementation facts.
+- Return JSON only.

devflow_engine/prompts/integration/validate/validate_repair/prompt.md

@@ -0,0 +1,20 @@
+# Validate Repair
+
+Repair only the failing workflow and idea-acceptance coverage surfaces so deterministic validation can continue.
+
+- Resolve every item in repair_sources with the smallest workflow + coverage delta that fixes the current failure.
+- Stay on the primary failing seam for each workflow and failing idea acceptance criterion; work only on remaining failing criteria/workflows and leave clean or already-proven sections untouched.
+- Treat protected_sections as immutable context and obey every item in do_not_touch.
+- When idea-acceptance failures are present, repair only the workflows/coverage entries needed to cover the failing criteria or restore the missing seam.
+- Do not re-summarize the full artifact on repair passes; update only the scoped enriched_workflows and scoped idea_acceptance_coverage entries you were given.
+- Do not revisit already-stable criteria unless you can cite a contradiction in the current artifact, and if you do, cite that contradiction explicitly in repair_delta_ledger.contradiction_citations.
+- Preserve workflow_ids, side-effect anchoring, criterion_index, criterion text, and any supported evidence.
+- Make missing code, runtime, or orchestration causes explicit instead of smuggling them into workflow or coverage edits.
+- Do not invent evidence, broaden workflow scope, or rewrite adjacent workflows/criteria.
+- Return enriched_workflows with the same workflow_ids and an updated idea_acceptance_coverage artifact.
+- Return repair_delta_ledger with all of:
+  - verdict_changes: every criterion/workflow verdict change made in this pass.
+  - evidence_changes: every new, removed, or corrected evidence reference used in this pass.
+  - newly_resolved_seams: each seam newly resolved in this pass.
+  - contradiction_citations: only contradictions in the current artifact that justify revisiting a stable criterion.
+- Return JSON only.

devflow_engine/prompts/integration/write_workflows/example.md

@@ -0,0 +1,100 @@
+# Write Workflows node assembled payload
+
+## Provenance
+
+Reconstructed from:
+
+- `prompts/integration/write_workflows/write_workflows/prompt.md`
+- `src/devflow_engine/integration/dag.py` write-workflows `context_payload`
+- `src/devflow_engine/agentic_runtime.py` prompt envelope builder
+- `WorkflowSetArtifact` in `src/devflow_engine/integration/dag.py`
+
+Not copied from a persisted past-run prompt artifact.
+
+## Stable doctrine vs actual payload
+
+- Stable node doctrine file: `prompts/integration/write_workflows/node_config/prompt.md`
+- Actual `instructions` come from `write_workflows/write_workflows/prompt.md`
+- Actual `context` comes from `task_context.metadata` + `event.*` in `integration/dag.py`
+- No skills or tools are injected here
+
+```json
+{
+  "task": "integration_write_workflows",
+  "instructions": [
+    "Write exactly one workflow per side effect.",
+    "Keep each workflow anchored to its side effect and attach the implicated users to that workflow.",
+    "Use only supported story_backing, code_backing, and source_doc_backing.",
+    "Include concrete interaction_points when implemented; otherwise use needed_interaction_points.",
+    "Capture process_sequence, branches when real, and resulting_artifacts; include mermaid only when it adds clarity.",
+    "Do not invent seams, unsupported implementation facts, or anchor_user.",
+    "Return JSON only."
+  ],
+  "context": {
+    "idea_id": "idea_checkout_recovery_v1",
+    "side_effects_artifact": {
+      "idea_id": "idea_checkout_recovery_v1",
+      "side_effects": [
+        {
+          "id": "se_recovery_email_sent",
+          "name": "Recovery email sent",
+          "rationale": "The implementation sends a recovery reminder after abandonment criteria are met.",
+          "interaction_points": [
+            {
+              "kind": "endpoint",
+              "name": "POST /api/carts/{cart_id}/recover",
+              "implemented": true
+            }
+          ],
+          "needed_interaction_points": [],
+          "process_sequence": [
+            "customer abandons cart",
+            "recovery endpoint or job is triggered",
+            "email delivery job is enqueued"
+          ],
+          "resulting_artifacts": ["queued recovery email job"]
+        }
+      ],
+      "alignment_context": {
+        "implemented_story_count": 2,
+        "code_evidence_count": 2,
+        "source_doc_count": 1
+      }
+    },
+    "implicated_users_artifact": {
+      "idea_id": "idea_checkout_recovery_v1",
+      "implicated_users": [
+        {
+          "kind": "human",
+          "scope": "customer_account",
+          "authority": "self",
+          "rationale": "The customer receives a reminder about their own abandoned cart."
+        }
+      ],
+      "denied_candidates": []
+    },
+    "implemented_stories": [
+      {
+        "story_id": "STORY-recovery-email-send",
+        "title": "Send recovery reminder email",
+        "side_effect_ids": ["se_recovery_email_sent"],
+        "required_planes": []
+      }
+    ],
+    "code_evidence": [
+      {
+        "path": "src/jobs/recovery_email_job.py",
+        "side_effect_ids": [],
+        "interaction_points": []
+      }
+    ],
+    "source_docs": [
+      {
+        "path": "ai_docs/context/v2/project_docs/user_workflows.md"
+      }
+    ]
+  },
+  "output_schema": "WorkflowSetArtifact.model_json_schema() from src/devflow_engine/integration/dag.py",
+  "return_format": "json_only"
+}
+```

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

@@ -0,0 +1,44 @@
+# Write Workflows Node Contract
+
+Write one workflow per implemented side effect from the provided evidence.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("write_workflows")`
+- `WriteWorkflowPerSideEffectNode.get_agent_config()`
+
+## What actually reaches the model
+
+The assembled prompt for this node is built from:
+
+- stage bullets in `prompts/integration/write_workflows/write_workflows/prompt.md`
+- runtime `context_payload` from `src/devflow_engine/integration/dag.py`
+- `WorkflowSetArtifact.model_json_schema()`
+- `return_format: "json_only"`
+
+## Real injected runtime components
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `implemented_stories` ← `event.implemented_stories`
+- `code_evidence` ← `event.code_evidence`
+- `source_docs` ← `event.source_docs`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/write_workflows/write_workflows/prompt.md`
+
+`output_schema` source:
+
+- `WorkflowSetArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- Provider/model/runtime transport is resolved later by `src/devflow_engine/llm/invoke.py`.

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

@@ -0,0 +1,44 @@
+# Write Workflows Node Contract
+
+Write one workflow artifact per side effect from implementation evidence.
+
+## What this file is
+
+Stable node doctrine loaded by:
+
+- `load_integration_node_instruction("write_workflows")`
+- `WriteWorkflowPerSideEffectNode.get_agent_config()`
+
+## What actually reaches the model
+
+The assembled prompt for this node is built from:
+
+- stage bullets in `prompts/integration/write_workflows/write_workflows/prompt.md`
+- runtime `context_payload` from `src/devflow_engine/integration/dag.py`
+- `WorkflowSetArtifact.model_json_schema()`
+- `return_format: "json_only"`
+
+## Real injected runtime components
+
+`context_payload` fields:
+
+- `idea_id` ← `event.idea_id`
+- `side_effects_artifact` ← `task_context.metadata["side_effects_artifact"]`
+- `implicated_users_artifact` ← `task_context.metadata["implicated_users_artifact"]`
+- `implemented_stories` ← `event.implemented_stories`
+- `code_evidence` ← `event.code_evidence`
+- `source_docs` ← `event.source_docs`
+
+`instructions` source:
+
+- bullets parsed from `prompts/integration/write_workflows/write_workflows/prompt.md`
+
+`output_schema` source:
+
+- `WorkflowSetArtifact.model_json_schema()`
+
+## Tools / skills / config
+
+- No integration-specific skills are injected.
+- No tool definitions are injected.
+- Provider/model/runtime transport is resolved later by `src/devflow_engine/llm/invoke.py`.

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

@@ -0,0 +1,17 @@
+# Write Workflows
+
+Write one workflow artifact per side effect from implementation evidence.
+
+- 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.
+- Write exactly one workflow per side effect.
+- Each workflow must stay anchored to the side effect and attach implicated users to that workflow.
+- Interaction points must be concrete when implemented; if required but missing, list them under needed_interaction_points instead of pretending they exist.
+- Include story_backing, code_backing, process_sequence, branches when relevant, resulting_artifacts, and optional mermaid when useful.
+- Do not anchor workflows to a user. Do not emit anchor_user.

devflow_engine/prompts/integration/write_workflows/write_workflows/prompt.md

@@ -0,0 +1,11 @@
+# Write Workflows
+
+Write one workflow per implemented side effect from the provided evidence.
+
+- Write exactly one workflow per side effect.
+- Keep each workflow anchored to its side effect and attach the implicated users to that workflow.
+- Use only supported story_backing, code_backing, and source_doc_backing.
+- Include concrete interaction_points when implemented; otherwise use needed_interaction_points.
+- Capture process_sequence, branches when real, and resulting_artifacts; include mermaid only when it adds clarity.
+- Do not invent seams, unsupported implementation facts, or anchor_user.
+- Return JSON only.

devflow_engine/prompts/iterate/README.md

@@ -0,0 +1,7 @@
+# Iterate prompt layer
+
+These files are the minimal prompt contracts for the Iterate lane.
+
+They should stay focused on model-visible role instructions only.
+
+Keep runtime wiring, tool configuration, orchestration mechanics, and operational policy outside this directory unless a model must reason over them directly.

devflow_engine/prompts/iterate/coder/prompt.md

@@ -0,0 +1,11 @@
+# Coder
+
+Implement only the scoped delta described by the provided task and observation artifacts, then report the attempt honestly.
+
+- Treat the task artifact and observation artifact as the governing contract.
+- Make the smallest change that can satisfy the stated green condition.
+- Stay inside scope unless Iterator explicitly changes it.
+- Run the narrowest valid verification seam.
+- Report what changed, what passed, what failed, and what remains blocked.
+- Do not broaden scope for opportunistic cleanup.
+- Do not self-certify final completion.

devflow_engine/prompts/iterate/framer/prompt.md

@@ -0,0 +1,11 @@
+# Framer
+
+Turn the provided request and local context into a bounded task artifact for a targeted change.
+
+- Classify the task as error_fix, quick_change, or targeted_improvement.
+- Distinguish current behavior from desired behavior.
+- Write observable success criteria.
+- Separate facts, assumptions, blocking unknowns, and nonblocking unknowns.
+- Recommend stay_iterate, investigate_first, or promote_to_idea.
+- Do not perform observation work.
+- Do not broaden the task to make it sound more important.

devflow_engine/prompts/iterate/iterator/prompt.md

@@ -0,0 +1,13 @@
+# Iterator
+
+Own the iterate task end to end using only the provided request, artifacts, and evidence, then return one truthful lane outcome.
+
+- Synthesize framing, observation, and attempt evidence without collapsing their roles.
+- Decide readiness before coding starts.
+- Keep scope aligned to the task contract.
+- When Observer shows the task is really diagnosis or investigation, call `devin_insight` as a tool to get an insight-level read before choosing the final lane outcome.
+- When the task expands beyond iterate-scale repair into broader feature or workflow shaping, call `call_devin_ideation` to promote into the ideation arm with iterate linkage intact.
+- Respawn only with repair-specific guidance when the task is still viable.
+- Block, reroute, or promote when truth or scope is insufficient.
+- Do not rewrite advisor conclusions casually.
+- Do not claim success without verification against the stated green condition.

devflow_engine/prompts/iterate/observer/prompt.md

@@ -0,0 +1,11 @@
+# Observer
+
+Turn the provided task artifact and local evidence into an observation artifact that states what is confirmed, what is not, and what green condition should govern verification.
+
+- Use only evidence that is explicitly available from logs, traces, repro steps, or inspected state.
+- Say confirmed, not_confirmed, or inconclusive plainly.
+- Define a bounded failing seam when direct repro is not the right frame.
+- State the expected green condition concretely.
+- Recommend whether the task is ready for coding.
+- Do not implement fixes.
+- Do not invent evidence or imply completion.

devflow_engine/prompts/recovery/diagnosis/prompt.md

@@ -0,0 +1,7 @@
+# Recovery Diagnosis
+
+- Return JSON only.
+- Diagnose the next bounded recovery move directly from the failure evidence and investigation.
+- Do not use or invent failure classes, fix families, candidate strategy registries, or class-backed routing.
+- Define verification_targets with explicit oracle fields.
+- Keep the diagnosis operational and specific to the concrete failed boundary.

devflow_engine/prompts/recovery/execution/prompt.md

@@ -0,0 +1,8 @@
+# Recovery Execution
+
+- Return JSON only.
+- Define concise success criteria for this recovery attempt.
+- Choose one outcome: reenqueue, delegated, or blocked.
+- Ground the execution attempt in the diagnosis success criteria and their oracles.
+- Do not use or invent failure classes, fix families, candidate strategy registries, or class-backed routing.
+- Perform recovery conceptually and then verify whether those success criteria were satisfied.

devflow_engine/prompts/recovery/execution_verification/prompt.md

@@ -0,0 +1,7 @@
+# Recovery Execution Verification
+
+- Return JSON only.
+- Validate whether the execution outcome satisfied the diagnosis success criteria and their oracles.
+- Set ready=true only if the recovery outcome is trustworthy enough to conclude recovery for this attempt.
+- Use blocking_reasons for hard contradictions, explicit human-required decisions, or exhausted bounded recovery.
+- Do not treat provenance or byte-identity uncertainty by itself as a viability contradiction when the repaired state is otherwise runnable.

devflow_engine/prompts/recovery/failure_investigation/prompt.md

@@ -0,0 +1,10 @@
+# Recovery Failure Investigation
+
+- Return JSON only.
+- Investigate the failed queue item as a process recovery problem.
+- When streamed agent logs, llm logs, or session logs are present in log_evidence, treat them as the primary evidence source before secondary artifacts or summaries.
+- Record the primary evidence source, its refs, and the key insight derived from those logs in the investigation output.
+- Identify the nature of the process failure and the affected boundary.
+- Define the recovery goal, success criteria, verification evidence, and escalation conditions.
+- Each success criterion must include an oracle describing what observable condition would prove it was met.
+- Keep the summary concise and specific.

devflow_engine/prompts/recovery/preflight_health_repo_repair/prompt.md

@@ -0,0 +1,8 @@
+# Recovery Preflight Health Repo Repair
+
+- Return JSON only.
+- Repair the repository code or config that caused the preflight health check failure.
+- Use file_patches with complete file contents for each repo file that must change.
+- Do not claim ready_to_requeue unless the repo/config repair is actually sufficient for a fresh health verification.
+- Do not emit fallback behavior that merely masks the failure.
+- Keep the fix bounded to the health-check boundary evidence in the provided report, setup contract, and logs.

devflow_engine/prompts/recovery/remediation_execution/prompt.md

@@ -0,0 +1,11 @@
+# Recovery Remediation Execution
+
+- Return JSON only.
+- You are the remediation executor. Apply the fix described in root_cause.specific_fix_plan.
+- For each file that needs changing, emit a FilePatch with path (repo-relative, e.g. 'src/devflow_engine/agentic_runtime.py') and content (COMPLETE new file contents — not a diff, the whole file).
+- Set fix_applied=true in your response (the orchestrator will write the files to disk).
+- Set ready_to_requeue=true if all systemic items can be safely re-enqueued after this fix.
+- items_to_requeue should list all affected_items that should be re-enqueued.
+- items_to_dead_letter should list any that should NOT be re-enqueued.
+- verification_notes should describe how to verify the fix worked.
+- Do NOT narrow scope. The fix must address the root cause for ALL affected items.

devflow_engine/prompts/recovery/root_cause_investigation/prompt.md

@@ -0,0 +1,12 @@
+# Recovery Root Cause Investigation
+
+- Return JSON only.
+- You are the root cause investigator for a systemic failure that killed multiple DevFlow queue items.
+- Read the key_source_files carefully to understand WHY failures occurred.
+- For 'Prompt is too long' failures: the likely root cause is that .claude/agents/*.md project context (~100KB+) is auto-loaded by claude CLI when invoked from the project directory, and the DAG prompts are already 50-120KB. The combined total exceeds Claude CLI limits. The artifact-reference fallback in agentic_runtime.py also fails because the CLI project context alone exceeds limits.
+- Identify the root_cause_location (filename:function or filename:line), root_cause_description, and specific_fix_plan.
+- fix_type must be one of: code_fix, config_fix, environment_fix, dead_letter, item_local_only.
+- confidence must be one of: high, medium, low.
+- List all files you read in files_inspected.
+- Set affects_all_items=true if the fix will unblock ALL systemic items once applied.
+- List any items in residual_items_needing_attention that still require individual attention after the systemic fix.

devflow_engine/prompts/scope_idea/doctrine/prompt.md

@@ -0,0 +1,7 @@
+# Scope Idea Doctrine
+
+- Approved scope is the anchor; enrich or split from it without silently replacing intent.
+- Return JSON only. No markdown. No prose outside JSON.
+- Canonical idea sufficiency remains downstream; do not pretend scope->idea output is story-ready.
+- Prefer evidence-backed interpretation over deterministic hints when the approved scope supports it.
+- Keep all assumptions explicit and preserve traceability to the approved scope and source evidence.

devflow_engine/prompts/source_doc_eval/document/prompt.md

@@ -0,0 +1,6 @@
+# Source Doc Eval Document
+
+- Score this single document only.
+- Quality is the chance this document alone would let a team deliver a functional, useful project from the information in it.
+- Completeness is how well the document answers reasonable questions for its topic.
+- Return quality and completeness as numbers between 0 and 1.

devflow_engine/prompts/source_doc_eval/targeted_mutation/prompt.md

@@ -0,0 +1,9 @@
+# Source Doc Eval Targeted Mutation
+
+- Assess the after-document against the targeted mutation request.
+- Quality is the chance this document alone would let a team deliver a functional, useful project from the information in it.
+- Completeness is how well the document answers reasonable questions for its topic.
+- appropriate_update measures whether the changed areas were updated correctly for the targeted mutation.
+- thoroughness measures whether all areas that should have been updated were actually updated.
+- accuracy must equal the average of appropriate_update and thoroughness.
+- Return all scores as numbers between 0 and 1.

devflow_engine/prompts/source_doc_mutation/domain_entities/prompt.md

@@ -0,0 +1,6 @@
+# Source Doc Mutation Domain Entities
+
+- Own only domain_entities.json.
+- Return entities, relationships, and ownership assumptions.
+- In sparse scenarios, infer the smallest viable business-object model needed to support the workflows and product framing, including relationship shape and data-authority assumptions when helpful.
+- Keep entity output compact and canonical; do not turn it into a full architecture document.

devflow_engine/prompts/source_doc_mutation/product_brief/prompt.md

@@ -0,0 +1,6 @@
+# Source Doc Mutation Product Brief
+
+- Own only product_brief.json.
+- Return a canonically sufficient but compact payload: summary, problem, users, goals, scope, non-goals, constraints, success criteria, and explicit product assumptions.
+- When intake is sparse, infer only the minimum useful planning depth and mark every meaningful gap-filling move as an assumption rather than pretending certainty.
+- Do not bloat the source doc into a pseudo-project-doc or pseudo-PRD.

devflow_engine/prompts/source_doc_mutation/project_doc_coherence/prompt.md

@@ -0,0 +1,7 @@
+# Source Doc Mutation Project Doc Coherence
+
+- Review the five project-doc outputs as one doc family, not isolated markdown files.
+- Use the supplied project-doc richness contract, agent contract, source-to-project-doc reference map, and cross-reference rules as explicit grounding/support contracts.
+- Check coverage/depth/traceability/consistency and cross-doc alignment against the canonical source docs.
+- Call out mismatches, unsupported elaboration, and still-thin areas explicitly rather than pretending the suite is richer than it is.
+- Return concise coherence notes only.