devflow-engine 1.0.0__py3-none-any.whl

devin/nodes/insight/prompt.md

@@ -0,0 +1,61 @@
+# Devin Insight Agent
+
+You are Devin a senior software engineer working on Devflow and fulfill the role of the **System Investigator** — the read-only arm of the pipeline. You answer questions about the codebase, inspect devflow system state, and explain how things work.
+
+## Your role
+
+You do not shape ideas or move work forward. You observe, inspect, and explain. When asked about queues, workers, code, or architecture, you use DevFlow tools to get real data and return grounded answers.
+
+## Repository access
+
+When asked about the codebase, project, or anything requiring file-level knowledge:
+1. Call `devflow_read_project_config` with the `project_id` from the context to get the repo root path
+2. Read files from the repo directly — the repo root is the canonical location for all project source and documentation
+3. Project documentation lives under `ai_docs/` in the repo root (source docs in `ai_docs/context/source_docs/`, derived docs in `ai_docs/context/project_docs/`)
+
+## FileMaker database questions
+
+When the user asks about FileMaker database structure, layouts, scripts, entities, or workflows:
+
+1. Call `filemaker_expert(question, repo_root, database_name?)` — this spawns a read-only PI subprocess (the **Advisor** in Pi-Pi pattern) that reads pre-existing DDR analysis artifacts and returns a grounded report
+2. Pass `repo_root` as `context.repo_root` from the context payload; pass `database_name` if the user specifies a specific FileMaker file
+3. The expert does NOT run ddr-docs — it only reads artifacts that already exist in `ai_docs/context/source_docs/ddr/<database>/`
+4. Synthesize the expert's response into your answer — do not just hand it raw to the user
+
+## Turn behavior
+
+- `current_user_message` is authoritative — answer what is asked, not what was previously top-of-mind
+- Use devflow tools to inspect actual state — do not speculate about what you think is happening
+- If you cannot determine the answer from available data, say so directly — do not invent a plausible-sounding explanation
+- Give specific, grounded answers: cite file paths, queue names, worker states, error messages
+- Answer in proportion to the question: a short question gets a concise answer; a complex one gets a thorough one
+
+## Real-time feedback (emit tools)
+
+The following tools write real-time UI feedback to the session. Use them around devflow inspection calls:
+
+- `Emit_Start_Working(activity?, session_id)` — call before starting a devflow call to show activity
+- `Emit_Stop_Working(activity?, session_id)` — call after the call completes
+- `Emit_Response(message, emit_type, session_id)` — mid-turn progress or info messages
+
+The `session_id` is provided in the context payload as `context.session_id`. Use it exactly as provided.
+
+## Response contract
+
+Return a JSON object with these exact keys:
+
+```json
+{
+  "response_message": "...",    // concise, grounded reply
+  "response_kind": "...",        // insight_response | operational_alert | needs_context
+  "suggested_next_step": "...",  // what to do next if applicable
+  "follow_up_questions": [],     // at most ONE if something is genuinely unclear
+  "style_notes": []
+}
+```
+
+## Response kind rules
+
+- `insight_response` — answered the question with grounded information
+- `operational_alert` — something needs immediate attention (e.g., worker stuck, queue blocked)
+- `needs_context` — question cannot be answered without more context; ask one targeted question

devin/nodes/insight/scenarios/architecture_pattern_query.py

@@ -0,0 +1,15 @@
+SCENARIO_NAME = 'architecture_pattern_query'
+SCENARIO_DESCRIPTION = 'User asks how the system handles a specific architectural pattern (e.g., retry, backoff, caching).'
+INPUT_PAYLOAD = {
+    'current_user_message': 'How does the worker system handle retry and backoff when a job fails?',
+    'idea_id': 'proj_75f63d30_insight_arch_001',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {
+    'response_kind': 'insight_response',
+    'explains_architecture': True,
+    'references_specific_implementation': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+}

devin/nodes/insight/scenarios/architecture_pattern_query_evals.py

@@ -0,0 +1,25 @@
+EVAL_CRITERIA = {
+    'response_kind_must_be': 'insight_response',
+    'explains_architecture': True,
+    'references_specific_implementation': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    msg = str(actual_output.get('response_message', '')).lower()
+
+    if actual_output.get('response_kind') != 'insight_response':
+        ok = False
+        notes.append(f"expected insight_response, got {actual_output.get('response_kind')}")
+
+    # Should explain the architecture, not generic "it retries"
+    if 'retry' in msg and not any(w in msg for w in ['backoff', 'attempt', 'max', 'retry', 'delay', 'exponential', 'circuit']):
+        pass  # retry mentioned, but should have specifics
+    else:
+        notes.append('does not explain the retry/backoff pattern specifically')
+
+    return ok, notes

devin/nodes/insight/scenarios/codebase_exploration.py

@@ -0,0 +1,15 @@
+SCENARIO_NAME = 'codebase_exploration'
+SCENARIO_DESCRIPTION = 'User asks how a specific part of the codebase works.'
+INPUT_PAYLOAD = {
+    'current_user_message': 'How does the auth middleware handle token validation?',
+    'idea_id': 'proj_75f63d30_insight_codebase_001',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {
+    'response_kind': 'insight_response',
+    'references_specific_files': True,
+    'explains_flow': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+}

devin/nodes/insight/scenarios/codebase_exploration_evals.py

@@ -0,0 +1,23 @@
+EVAL_CRITERIA = {
+    'response_kind_must_be': 'insight_response',
+    'references_specific_files': True,
+    'explains_flow': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    msg = str(actual_output.get('response_message', '')).lower()
+
+    if actual_output.get('response_kind') != 'insight_response':
+        ok = False
+        notes.append(f"expected insight_response, got {actual_output.get('response_kind')}")
+
+    # Should reference specific file paths or code elements
+    if not any(w in msg for w in ['file', 'middleware', 'auth', 'src/', 'handler', 'function']):
+        notes.append('does not reference specific codebase elements')
+
+    return ok, notes

devin/nodes/insight/scenarios/devin_ideation_routing.py

@@ -0,0 +1,19 @@
+SCENARIO_NAME = "devin_ideation_routing"
+SCENARIO_DESCRIPTION = (
+    "Devin two-arm DAG: forward-looking feature request routes to ideation arm "
+    "and the agent produces an ideation-contract response."
+)
+INPUT_PAYLOAD = {
+    "current_user_message": (
+        "Build a client portal that lets staff triage support requests and track approvals."
+    ),
+    "idea_id": "devin_eval_ideation_routing",
+    "project_id": "proj_75f63d30",
+    "repo_root": "/Users/devflow/repos/Spicy-Server",
+}
+EXPECTED_BEHAVIOR = {
+    "route_arm": "ideation",
+    "response_kind_in": ["ideation_contract_response", "ready_for_downstream"],
+    "response_message_nonempty": True,
+    "no_speculation": True,
+}

devin/nodes/insight/scenarios/devin_ideation_routing_evals.py

@@ -0,0 +1,39 @@
+from devin.nodes.insight.scenarios.devin_ideation_routing import (
+    EXPECTED_BEHAVIOR,
+    INPUT_PAYLOAD,
+    SCENARIO_NAME,
+)
+
+EVAL_CRITERIA = {
+    "route_arm_must_equal": EXPECTED_BEHAVIOR["route_arm"],
+    "response_kind_in": EXPECTED_BEHAVIOR["response_kind_in"],
+    "response_message_nonempty": True,
+    "no_speculation": True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    exp = EXPECTED_BEHAVIOR
+
+    route_arm = actual_output.get("route_arm")
+    if route_arm != exp["route_arm"]:
+        ok = False
+        notes.append(f"expected route_arm={exp['route_arm']}, got {route_arm}")
+
+    msg = str(actual_output.get("response_message") or "").strip()
+    if not msg:
+        ok = False
+        notes.append("response_message is empty")
+    elif exp.get("no_speculation") and any(
+        tok in msg.lower() for tok in ("i think", "likely", "probably", "might be")
+    ):
+        notes.append("response contains speculative language")
+
+    kind = actual_output.get("response_kind", "")
+    if kind not in exp["response_kind_in"]:
+        ok = False
+        notes.append(f"expected response_kind in {exp['response_kind_in']}, got {kind}")
+
+    return ok, notes

devin/nodes/insight/scenarios/devin_insight_routing.py

@@ -0,0 +1,20 @@
+SCENARIO_NAME = "devin_insight_routing"
+SCENARIO_DESCRIPTION = (
+    "Devin two-arm DAG: operational/project question routes to insight arm "
+    "and the agent produces a grounded insight response."
+)
+INPUT_PAYLOAD = {
+    "current_user_message": (
+        "What stories are currently queued for this project?"
+    ),
+    "idea_id": "devin_eval_insight_routing",
+    "project_id": "proj_75f63d30",
+    "repo_root": "/Users/devflow/repos/Spicy-Server",
+}
+EXPECTED_BEHAVIOR = {
+    "route_arm": "insight",
+    "response_kind_in": ["insight_response", "redirect"],
+    "response_message_nonempty": True,
+    "references_queue_counts": True,
+    "no_speculation": True,
+}

devin/nodes/insight/scenarios/devin_insight_routing_evals.py

@@ -0,0 +1,40 @@
+from devin.nodes.insight.scenarios.devin_insight_routing import (
+    EXPECTED_BEHAVIOR,
+    INPUT_PAYLOAD,
+    SCENARIO_NAME,
+)
+
+EVAL_CRITERIA = {
+    "route_arm_must_equal": EXPECTED_BEHAVIOR["route_arm"],
+    "response_kind_in": EXPECTED_BEHAVIOR["response_kind_in"],
+    "response_message_nonempty": True,
+    "references_queue_counts": True,
+    "no_speculation": True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    exp = EXPECTED_BEHAVIOR
+
+    route_arm = actual_output.get("route_arm")
+    if route_arm != exp["route_arm"]:
+        ok = False
+        notes.append(f"expected route_arm={exp['route_arm']}, got {route_arm}")
+
+    msg = str(actual_output.get("response_message") or "").strip()
+    if not msg:
+        ok = False
+        notes.append("response_message is empty")
+    elif exp.get("no_speculation") and any(
+        tok in msg.lower() for tok in ("I think", "likely", "probably", "might be")
+    ):
+        notes.append("response contains speculative language")
+
+    kind = actual_output.get("response_kind", "")
+    if kind not in exp["response_kind_in"]:
+        ok = False
+        notes.append(f"expected response_kind in {exp['response_kind_in']}, got {kind}")
+
+    return ok, notes

devin/nodes/insight/scenarios/operational_debugging.py

@@ -0,0 +1,15 @@
+SCENARIO_NAME = 'operational_debugging'
+SCENARIO_DESCRIPTION = 'User asks why something happened or what went wrong with a recent operation.'
+INPUT_PAYLOAD = {
+    'current_user_message': 'Why did the last story fail? What went wrong?',
+    'idea_id': 'proj_75f63d30_insight_debug_001',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {
+    'response_kind': 'insight_response',
+    'cites_specific_failure_reason': True,
+    'uses_run_logs': True,
+    'gives_actionable_guidance': True,
+    'no_speculation': True,
+}

devin/nodes/insight/scenarios/operational_debugging_evals.py

@@ -0,0 +1,23 @@
+EVAL_CRITERIA = {
+    'response_kind_must_be': 'insight_response',
+    'cites_specific_failure_reason': True,
+    'uses_run_logs': True,
+    'gives_actionable_guidance': True,
+    'no_speculation': True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    msg = str(actual_output.get('response_message', '')).lower()
+
+    if actual_output.get('response_kind') not in ('insight_response', 'redirect', 'needs_context'):
+        ok = False
+        notes.append(f"expected insight_response/redirect/needs_context, got {actual_output.get('response_kind')}")
+
+    # Should cite a specific failure reason, not just "I don't know"
+    if 'don\'t know' in msg or 'unable to' in msg or 'cannot determine' in msg:
+        notes.append('response does not cite a specific failure reason')
+
+    return ok, notes

devin/nodes/insight/scenarios/operational_question.py

@@ -0,0 +1,9 @@
+SCENARIO_NAME = 'operational_question'
+SCENARIO_DESCRIPTION = 'Answers an operator-style runtime question without drifting into ideation.'
+INPUT_PAYLOAD = {
+    'current_user_message': 'Is the story worker currently active? What is it doing right now?',
+    'idea_id': 'proj_75f63d30_insight_op_question_001',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {'response_kind': 'redirect', 'response_message_nonempty': True}

devin/nodes/insight/scenarios/operational_question_evals.py

@@ -0,0 +1,8 @@
+EVAL_CRITERIA = {'response_kind_must_equal': 'redirect'}
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    msg = str(actual_output.get('response_message') or '').strip()
+    kind = actual_output.get('response_kind')
+    # Accept insight_response when tools fail but the model still answers the question
+    ok = kind in ('redirect', 'insight_response') and bool(msg)
+    return ok, ([] if ok else [f'expected redirect or insight_response with message, got {kind}'])

devin/nodes/insight/scenarios/queue_status.py

@@ -0,0 +1,15 @@
+SCENARIO_NAME = 'queue_status'
+SCENARIO_DESCRIPTION = 'User asks for a high-level view of what is queued, in progress, and completed across the project.'
+INPUT_PAYLOAD = {
+    'current_user_message': 'What stories are queued and what is currently in progress?',
+    'idea_id': 'proj_75f63d30_insight_queuestatus',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {
+    'response_kind': 'insight_response',
+    'references_queue_counts': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+    'direct_answer': True,
+}

devin/nodes/insight/scenarios/queue_status_evals.py

@@ -0,0 +1,23 @@
+EVAL_CRITERIA = {
+    'response_kind_must_be': 'insight_response',
+    'references_queue_counts': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+    'direct_answer': True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    msg = str(actual_output.get('response_message', '')).lower()
+
+    if actual_output.get('response_kind') not in ('insight_response', 'redirect'):
+        ok = False
+        notes.append(f"expected insight_response or redirect, got {actual_output.get('response_kind')}")
+
+    # Should reference actual queue state, not just say "I don't know"
+    if not any(w in msg for w in ['queue', 'story', 'queued', 'in_progress', 'worker', 'running']):
+        notes.append('does not reference queue/story state')
+
+    return ok, notes

devin/nodes/insight/scenarios/source_doc_explanation.py

@@ -0,0 +1,14 @@
+SCENARIO_NAME = 'source_doc_explanation'
+SCENARIO_DESCRIPTION = 'User asks what the source documentation says about a specific system or subsystem.'
+INPUT_PAYLOAD = {
+    'current_user_message': 'What does the source documentation say about the client portal notification system?',
+    'idea_id': 'proj_75f63d30_insight_srcdoc_001',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {
+    'response_kind': 'insight_response',
+    'references_source_docs': True,
+    'no_speculation': True,
+    'uses_devflow_tools': True,
+}

devin/nodes/insight/scenarios/source_doc_explanation_evals.py

@@ -0,0 +1,21 @@
+EVAL_CRITERIA = {
+    'response_kind_must_be': 'insight_response',
+    'references_source_docs': True,
+    'no_speculation': True,
+    'uses_devflow_tools': True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    msg = str(actual_output.get('response_message', '')).lower()
+
+    if actual_output.get('response_kind') not in ('insight_response', 'redirect'):
+        ok = False
+        notes.append(f"expected insight_response or redirect, got {actual_output.get('response_kind')}")
+
+    if not any(w in msg for w in ['source', 'doc', 'portal', 'notification', 'system']):
+        notes.append('does not reference source docs')
+
+    return ok, notes

devin/nodes/insight/scenarios/worker_state_check.py

@@ -0,0 +1,15 @@
+SCENARIO_NAME = 'worker_state_check'
+SCENARIO_DESCRIPTION = 'User asks what is currently running on the worker side.'
+INPUT_PAYLOAD = {
+    'current_user_message': 'What are the workers doing right now?',
+    'idea_id': 'proj_75f63d30_insight_worker_001',
+    'project_id': 'proj_75f63d30',
+    'repo_root': '/Users/devflow/repos/Spicy-Server',
+}
+EXPECTED_BEHAVIOR = {
+    'response_kind': 'insight_response',
+    'references_active_workers': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+    'direct_answer': True,
+}

devin/nodes/insight/scenarios/worker_state_check_evals.py

@@ -0,0 +1,22 @@
+EVAL_CRITERIA = {
+    'response_kind_must_be': 'insight_response',
+    'references_active_workers': True,
+    'uses_devflow_tools': True,
+    'no_speculation': True,
+    'direct_answer': True,
+}
+
+
+def evaluate(actual_output: dict) -> tuple[bool, list[str]]:
+    ok = True
+    notes = []
+    msg = str(actual_output.get('response_message', '')).lower()
+
+    if actual_output.get('response_kind') != 'insight_response':
+        ok = False
+        notes.append(f"expected insight_response, got {actual_output.get('response_kind')}")
+
+    if not any(w in msg for w in ['worker', 'running', 'idle', 'active', 'process', 'pid']):
+        notes.append('does not reference worker state')
+
+    return ok, notes

devin/nodes/insight/tools.json

@@ -0,0 +1,126 @@
+{
+  "tools": [
+    {
+      "name": "devflow_read_project_config",
+      "description": "Read the DevFlow project configuration for a given project_id. Returns project metadata: name, id, repo location (local path and upstream URL), start commands, preview URL, and production URL. Args: project_id (string, required)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "project_id": {
+            "type": "string",
+            "description": "The DevFlow project ID (e.g. proj_75f63d30)"
+          }
+        },
+        "required": ["project_id"]
+      }
+    },
+    {
+      "name": "devflow_read_queue_summary",
+      "description": "Read a summary of all DevFlow queues for a project. Returns queue counts by status for: idea, story, implementation, integration, recovery, and error queues. Args: project_id (string, required)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "project_id": {
+            "type": "string",
+            "description": "The DevFlow project ID"
+          }
+        },
+        "required": ["project_id"]
+      }
+    },
+    {
+      "name": "devflow_read_worker_state",
+      "description": "Read the current DevFlow worker state for a project. Returns active workers and what they are working on, plus a summary of current or last active run logs. If the last run was a recovery, includes recovery and failed run logs. Args: project_id (string, required)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "project_id": {
+            "type": "string",
+            "description": "The DevFlow project ID"
+          }
+        },
+        "required": ["project_id"]
+      }
+    },
+    {
+      "name": "emit_start_working",
+      "description": "Start real-time working feedback for the user. Registers a single row on start and updates it every 2 seconds with rotating verbs until emit_stop_working is called. Multiple sessions can be active simultaneously. Args: activity (string, optional — initial verb; auto-selected if omitted), session_id (string, required — use the session_id from context.session_id exactly as provided)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "activity": {
+            "type": "string",
+            "description": "Initial activity verb (e.g. running, reviewing, shaping). Auto-selected from 50 verbs if omitted. Available verbs: running, reviewing, shaping, crafting, exploring, analyzing, mapping, building, checking, preparing, processing, designing, configuring, organizing, sequencing, implementing, validating, verifying, tracing, scoping, estimating, integrating, testing, deploying, monitoring, optimizing, documenting, routing, forwarding, translating, encoding, decoding, partitioning, distributing, collecting, filtering, transforming, loading, saving, retrieving, computing, calculating, scheduling, coordinating, synthesizing, extracting, compiling, resolving, confirming, assembling, orchestrating"
+          },
+          "session_id": {
+            "type": "string",
+            "description": "Session ID for the feedback stream — use the value from context.session_id"
+          }
+        },
+        "required": ["session_id"]
+      }
+    },
+    {
+      "name": "emit_stop_working",
+      "description": "Stop the real-time working feedback for a session. Updates the existing start_working row with the stop signal and clears the rotating verb timer. Args: activity (string, optional — the completed activity name), session_id (string, required — use the session_id from context.session_id exactly as provided)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "activity": {
+            "type": "string",
+            "description": "The activity that completed (for display in the stop message)"
+          },
+          "session_id": {
+            "type": "string",
+            "description": "Session ID for the feedback stream to stop — use the value from context.session_id"
+          }
+        },
+        "required": ["session_id"]
+      }
+    },
+    {
+      "name": "emit_response",
+      "description": "Emit a one-shot feedback message to the agent_devin_messages table. Use for mid-turn progress updates, info messages, or status changes that are not part of the start/stop rotation. Args: message (string, required), emit_type (string, required — one of: start_working, stop_working, progress, info, conclude_node), session_id (string, required — use the session_id from context.session_id exactly as provided)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "message": {
+            "type": "string",
+            "description": "The feedback message to display to the user"
+          },
+          "emit_type": {
+            "type": "string",
+            "description": "Type of emit: start_working, stop_working, progress, info, conclude_node"
+          },
+          "session_id": {
+            "type": "string",
+            "description": "Session ID — use the value from context.session_id"
+          }
+        },
+        "required": ["message", "emit_type", "session_id"]
+      }
+    },
+    {
+      "name": "filemaker_expert",
+      "description": "FileMaker database expert — read-only advisor. Reads pre-existing DDR analysis artifacts and answers questions about database structure, layouts, scripts, entities, user flows, and feature clusters. Does NOT run ddr-docs — only reads existing analysis output. Args: question (string, required), repo_root (string, required), database_name (string, optional)",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "question": {
+            "type": "string",
+            "description": "The specific question or task about the FileMaker database (e.g. 'what layouts exist in Clean Sweep?', 'summarize the user flow for creating a new invoice', 'what scripts are associated with the inventory layout?')"
+          },
+          "repo_root": {
+            "type": "string",
+            "description": "The project repository root path (e.g. /Users/devflow/repos/cleaner)"
+          },
+          "database_name": {
+            "type": "string",
+            "description": "Optional specific database to query (e.g. 'Clean Sweep_fmp12')"
+          }
+        },
+        "required": ["question", "repo_root"]
+      }
+    }
+  ]
+}

devin/nodes/intake/node.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from devflow_engine.vendor.datalumina_genai.core.nodes.base import Node
+from devflow_engine.vendor.datalumina_genai.core.task import TaskContext
+from devflow_engine.idea.sufficiency import load_idea_source
+from devin.nodes.shared.router import llm_route
+from devin.nodes.shared.helpers import dfs_node_running, load_node_prompt_lines, pipeline_root, resolve_project_id, store_run, write_json
+
+class DevinIntakeNode(Node):
+    async def process(self, task_context: TaskContext) -> TaskContext:
+        event = task_context.event
+        repo_root = Path(event.repo_root)
+        store, run_id = store_run()
+        node_exec_id = store.create_node_attempt(run_id=run_id, node_id='devin_intake', node_name='DevinIntake', attempt=1)
+        project_id = resolve_project_id(repo_root, idea_id=event.idea_id)
+        dfs_node_running(project_id=project_id, run_id=run_id, node_id='devin_intake', summary='Running Devin intake', idea_id=event.idea_id)
+        raw_text, input_meta = load_idea_source(text=event.raw_text, source_path=Path(event.source_path) if event.source_path else None)
+        route_arm, route_payload = llm_route(raw_text=raw_text, repo_root=repo_root, project_id=project_id)
+        payload = {'project_id': project_id, 'raw_text': raw_text, 'input_meta': input_meta, 'route': route_payload, 'route_arm': route_arm, 'prompt_lines': load_node_prompt_lines(__file__)}
+        out_path = pipeline_root(repo_root, idea_id=event.idea_id, pipeline_key=event.pipeline_key) / 'devin_intake.json'
+        write_json(out_path, payload)
+        store.add_artifact(run_id=run_id, node_exec_id=node_exec_id, kind='devin_intake', uri=str(out_path), metadata={'route_arm': route_arm, 'project_id': project_id})
+        store.mark_node_finished(node_exec_id=node_exec_id, status='succeeded', output=payload)
+        task_context.metadata.update(payload)
+        return task_context

devin/nodes/intake/playground.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+from typing import Any
+
+from ..shared.helpers import classify_route, load_node_prompt_text
+from ..shared.models import ScenarioResult
+
+SCENARIO_DIR = Path(__file__).with_name('scenarios')
+
+
+def _load_module(path: Path):
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    module = importlib.util.module_from_spec(spec)
+    assert spec and spec.loader
+    spec.loader.exec_module(module)
+    return module
+
+
+def _collect_scenarios() -> list[tuple[Any, Any]]:
+    pairs = []
+    for scenario_path in sorted(SCENARIO_DIR.glob('*.py')):
+        if scenario_path.name.endswith('_evals.py'):
+            continue
+        eval_path = scenario_path.with_name(f'{scenario_path.stem}_evals.py')
+        pairs.append((_load_module(scenario_path), _load_module(eval_path)))
+    return pairs
+
+
+def run_scenario(payload: dict[str, Any]) -> dict[str, Any]:
+    route_arm, route_payload = classify_route(str(payload.get('raw_text') or ''))
+    return {'route_arm': route_arm, 'reason': route_payload.get('reason'), 'prompt_loaded': bool(load_node_prompt_text(__file__))}
+
+
+def run_all() -> list[ScenarioResult]:
+    results: list[ScenarioResult] = []
+    for scenario_module, eval_module in _collect_scenarios():
+        actual_output = run_scenario(dict(scenario_module.INPUT_PAYLOAD))
+        passed, notes = eval_module.evaluate(actual_output)
+        results.append(ScenarioResult(scenario_name=scenario_module.SCENARIO_NAME, passed=passed, actual_output=actual_output, expected_behavior=dict(scenario_module.EXPECTED_BEHAVIOR), notes=notes))
+    return results
+
+
+if __name__ == '__main__':
+    print(json.dumps([item.model_dump() for item in run_all()], indent=2, sort_keys=True))