devflow-engine 1.1.25__tar.gz → 1.1.27__tar.gz

{devflow_engine-1.1.25 → devflow_engine-1.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devflow-engine
-Version: 1.1.25
+Version: 1.1.27
 Summary: DevFlow v2 CLI-first engine (projects, stories, execution store, review packets)
 Author: DevFlow
 License: Proprietary
@@ -34,6 +34,7 @@ CLI-first Python engine for DevFlow v2.
 
 ## Documentation
 - `docs/story-implementation-planning-node.md` — per-story planning/gating node before TestDesign/Red, with dependency findings, queue decisions, and registry expectations consumed by downstream implementation nodes.
+- `docs/production-happy-path.md` — production control-plane, queue, idea-to-story, story implementation, recovery, and integration happy path.
 
 ## Install / Dev
 This repo is intended to be run with **uv**.

{devflow_engine-1.1.25 → devflow_engine-1.1.27}/README.md

@@ -15,6 +15,7 @@ CLI-first Python engine for DevFlow v2.
 
 ## Documentation
 - `docs/story-implementation-planning-node.md` — per-story planning/gating node before TestDesign/Red, with dependency findings, queue decisions, and registry expectations consumed by downstream implementation nodes.
+- `docs/production-happy-path.md` — production control-plane, queue, idea-to-story, story implementation, recovery, and integration happy path.
 
 ## Install / Dev
 This repo is intended to be run with **uv**.

devflow_engine-1.1.27/docs/production-happy-path.md

@@ -0,0 +1,190 @@
+# DevFlow Engine Production Happy Path
+
+This document describes the target production path for DevFlow Engine as implemented in this repo today. It is intentionally about the normal path: what should happen when project setup, planning, queue execution, implementation, and visibility all succeed.
+
+## System Roles
+
+- DevFlow Host owns deployment and per-project engine containers.
+- Supabase is the shared control plane and visibility plane.
+- DevFlow Engine owns authoritative execution inside the project workspace.
+- `.devflow/execution.sqlite` is the local execution source of truth for runs, queues, node outputs, artifacts, worker state, and recovery handoffs.
+- `devflow_state` and related Supabase projections are frontend visibility, not execution authority.
+
+## Deployment Path
+
+1. A DevFlow Engine version is published as the `devflow-engine` Python package.
+2. DevFlow Host pins that version through `ENGINE_VERSION`.
+3. The host controller rebuilds/restarts project engine containers.
+4. A per-project engine container runs the `devflow` CLI with project-specific environment and credentials.
+
+The operator commands for publishing and host pinning live in `OPERATOR.md`.
+
+## Control-Plane Event Path
+
+The production control-plane entrypoint is:
+
+```bash
+devflow worker supabase-events
+```
+
+The worker watches `devflow_execution_events`, using Realtime wakeups when available and polling as fallback.
+
+Happy path:
+
+1. Supabase receives a supported event with `status = queued` and `run_id IS NULL`.
+2. `DevflowEventWorkerLoopService` wakes, fetches the event, and atomically claims it as `processing`.
+3. `DevflowEventWorkerService` dispatches the event to the matching local workflow.
+4. The workflow writes authoritative local run/artifact/queue state.
+5. The event is completed or failed in Supabase.
+6. `devflow_state` is updated so the frontend can show current project status.
+
+Supported production event families are documented in `docs/queue-worker-infra.md`; examples include project init/import, source docs, source-to-scope, idea intake, idea-to-stories, settings changes, and API key transport.
+
+## Project Registration Path
+
+Production project setup starts from either:
+
+```bash
+devflow project init --name <name>
+devflow project import <repo-spec-or-path>
+```
+
+Happy path:
+
+1. The control plane has a project shell or the CLI receives enough information to bind one.
+2. DevFlow Engine resolves or creates a workspace.
+3. The registration DAG binds the workspace/repo to a project id.
+4. Local `.devflow/` state and `.devflow/execution.sqlite` are initialized.
+5. The project registry records the project selector, workspace path, repo root, and remote URL when available.
+6. Registration reaches `engine_registered`.
+7. Shared state is projected as `ready_for_source_scope`.
+
+The key rule is that DevFlow Engine owns the local execution truth. Supabase carries project/control-plane state and frontend visibility.
+
+## Planning Path
+
+The normal planning progression is:
+
+1. Source docs are created or updated.
+2. Source docs are converted into candidate scopes.
+3. An approved scope creates an idea.
+4. A sufficiently grounded idea creates DevFlow stories.
+5. Stories are queued for implementation.
+
+The queue-backed path is preferred for production execution:
+
+```bash
+devflow worker start --project <project-id>
+```
+
+`process_once` claims one queue item; `drain_project_queue` keeps processing until the current queue is empty or the next queue type should take over.
+
+Queue priority order in the project worker is:
+
+1. source docs maintenance
+2. quick actions
+3. errors
+4. recovery
+5. scope-to-idea
+6. idea creation
+7. idea-to-story
+8. source doc mutation
+9. story implementation
+10. integration
+
+## Idea-To-Story Path
+
+The production idea-to-story lane is queue-backed through `idea_queue`.
+
+Happy path:
+
+1. An idea queue row is created with an idea payload path and candidate planes.
+2. `devflow worker start --project <project-id>` claims the row.
+3. The worker starts a `worker.idea_to_story` run.
+4. `run_idea_to_devflow_stories_dag` validates sufficiency and normalizes actor context.
+5. Traditional stories are generated and gated.
+6. DevFlow story contracts are compiled.
+7. Story artifacts are persisted.
+8. `story_queue` rows are enqueued for each compiled story.
+9. The idea queue item is marked `completed`.
+
+The actor registry is part of the happy path, not a side detail. Generated coverage requirements and stories must resolve to canonical actors before downstream story compilation is considered trustworthy.
+
+## Story Implementation Path
+
+The production story lane is queue-backed through `story_queue`.
+
+Happy path:
+
+1. A queued story row references a persisted story artifact.
+2. The project worker claims the story row and starts a `worker.story.execute` wrapper run.
+3. The worker marks the story row `in_progress`.
+4. `process_dag.run_process_dag` runs the actual implementation DAG.
+5. Implementation DAG nodes create child runs/artifacts as needed.
+6. On success, the local story status becomes `implemented`.
+7. Supabase story status is updated to `implemented`.
+8. `devflow_state` is projected as implementation complete.
+9. The story queue row is marked `completed`.
+
+When investigating this path, do not stop at the wrapper run. Trace both the `worker.story.execute` wrapper run and the child implementation DAG run(s).
+
+## Recovery Path
+
+Recovery is part of production, but not part of the happy path.
+
+If a queue item fails in a recoverable lane, the worker:
+
+1. marks the active run failed,
+2. marks the queue item failed or blocked,
+3. persists failure context,
+4. creates a `recovery_queue` request,
+5. stops the worker cleanly.
+
+`devflow worker recover --project <project-id>` is for stale worker ownership state, not normal queue progress.
+
+## Integration Path
+
+After stories are implemented, integration work can be prepared and queued:
+
+```bash
+devflow integration prepare <idea-id>
+devflow integration enqueue <idea-id> --project <project-id>
+devflow worker start --project <project-id>
+```
+
+Happy path:
+
+1. Integration payload is prepared from implemented idea/stories, code evidence, and source docs.
+2. `integration_queue` receives a queued row.
+3. The project worker claims it and starts `worker.integration`.
+4. `run_integration_dag` evaluates integration readiness.
+5. Integration artifacts are written under the idea's integration directory.
+6. Supabase integration state and `devflow_state` are updated.
+7. The integration queue row is marked `completed`.
+
+## What Counts As Production Complete
+
+A production happy-path claim is only complete when all of these are true:
+
+- The command/event has a real entrypoint.
+- The authoritative local state transition is persisted in `.devflow/execution.sqlite`.
+- Artifacts needed for replay or review are written to stable paths.
+- Queue rows move from `queued` to `in_progress` to `completed`.
+- Supabase visibility is updated where the frontend depends on it.
+- Failures preserve enough context to enqueue recovery or support operator diagnosis.
+
+Tests that only assert mocks were called do not prove this path. Tests should verify durable local state and, where relevant, Supabase projection calls or readbacks.
+
+## Recently Repaired Red-Test Clusters Against This Path
+
+The repair pass that introduced this document focused on failures that were still on the production happy path:
+
+- idea-to-story actor normalization and canonical actor id repair,
+- project init/import backend provisioning and bootstrap story synthesis,
+- story execution wrapper run closure on success, failure, and crashes,
+- implementation DAG setup/preflight/dependency/planning/test-design/red happy-path progression,
+- recovery DAG classification and queue re-enqueue behavior,
+- worker project root resolution from registry entries,
+- runtime error solver behavior for unresolved projects versus local repro/coder paths.
+
+The full test suite was green after these repairs. The next useful repair step is to keep broadening production-lane proof with durable state assertions rather than mock-only completion checks.

{devflow_engine-1.1.25 → devflow_engine-1.1.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devflow-engine"
-version = "1.1.25"
+version = "1.1.27"
 description = "DevFlow v2 CLI-first engine (projects, stories, execution store, review packets)"
 readme = "README.md"
 requires-python = ">=3.11"

{devflow_engine-1.1.25 → devflow_engine-1.1.27}/scripts/audit_llm_invocations.py

@@ -266,17 +266,9 @@ INVENTORY: tuple[InventoryRow, ...] = (
         notes="Failure classification, diagnosis, strategy, execution, and verification all route through the current canonical seam.",
         tests=("tests/area10_process_pipeline/test_failure_recovery_dag.py", "tests/area10_process_pipeline/test_recovery_dag_model_tier.py"),
     ),
-    InventoryRow(
-        id="devin.devin_eval._assess_response",
-        file="src/devflow_engine/devin/devin_eval.py",
-        function="_assess_response",
-        invocation="run_agent_step",
-        classification="canonical_wrapper_eval",
-        live_status="live_opt_in",
-        owner="Opt-in eval harness",
-        notes="Opt-in real-eval harness; not worker-happy-path, but still a live invocation path when explicitly enabled.",
-        tests=("tests/test_devin_real_eval.py",),
-    ),
+    # Devin entries removed: devin_eval.py / devin_chat_dag are no longer
+    # part of the engine (1-line shim re-exports a removed package).
+    # Keeping the dead InventoryRow here would always report uncovered.
     InventoryRow(
         id="source_doc_mutation_eval._assess_doc",
         file="src/devflow_engine/source_doc_mutation_eval.py",
@@ -288,28 +280,8 @@ INVENTORY: tuple[InventoryRow, ...] = (
         notes="Opt-in real-eval harness for source-doc mutation quality.",
         tests=("tests/test_source_doc_mutation_eval.py", "tests/test_source_doc_mutation_real_eval.py"),
     ),
-    InventoryRow(
-        id="idea.agentic._anthropic_messages_create",
-        file="src/devflow_engine/idea/agentic.py",
-        function="_anthropic_messages_create",
-        invocation="urllib.request.urlopen",
-        classification="direct_provider_api_exception",
-        live_status="live",
-        owner="DFE ideation/insight arm",
-        notes="Direct Anthropic HTTP transport. Current exception that must migrate into the future canonical invocation surface.",
-        tests=("tests/area10_process_pipeline/test_df2_proc_1002_ideation_api_agent.py",),
-    ),
-    InventoryRow(
-        id="idea.agentic._run_api_agent",
-        file="src/devflow_engine/idea/agentic.py",
-        function="_run_api_agent",
-        invocation="_anthropic_messages_create",
-        classification="direct_provider_api_exception",
-        live_status="live",
-        owner="DFE ideation/insight arm",
-        notes="Structured tool-loop over the direct Anthropic transport.",
-        tests=("tests/area10_process_pipeline/test_df2_proc_1002_ideation_api_agent.py",),
-    ),
+    # idea.agentic entries removed (test file deleted in devin cleanup)
+    # idea.agentic entries removed (test file deleted in devin cleanup)
     InventoryRow(
         id="idea.actors._call_json_llm",
         file="src/devflow_engine/idea/actors.py",
@@ -343,39 +315,8 @@ INVENTORY: tuple[InventoryRow, ...] = (
         notes="Direct one-shot bypass around the canonical seam.",
         tests=("tests/area10_process_pipeline/test_df2_proc_1001_idea_story_dag_red.py",),
     ),
-    InventoryRow(
-        id="idea.devin_chat_dag._llm_classify_route",
-        file="src/devflow_engine/idea/devin_chat_dag.py",
-        function="_llm_classify_route",
-        invocation="run_one_shot",
-        classification="direct_cli_bypass",
-        live_status="live",
-        owner="Devin chat DAG",
-        notes="Direct route-classifier bypass around the canonical seam.",
-        tests=("tests/area10_process_pipeline/test_df2_proc_1002_route_classifier.py",),
-    ),
-    InventoryRow(
-        id="idea.devin_chat_dag._complete_contract_via_llm",
-        file="src/devflow_engine/idea/devin_chat_dag.py",
-        function="_complete_contract_via_llm",
-        invocation="run_one_shot",
-        classification="direct_cli_bypass",
-        live_status="live",
-        owner="Devin chat DAG",
-        notes="Direct contract-completion bypass around the canonical seam.",
-        tests=("tests/area10_process_pipeline/test_df2_proc_1002_route_classifier.py",),
-    ),
-    InventoryRow(
-        id="idea.devin_chat_dag.IdeationAgentLoopNode.process",
-        file="src/devflow_engine/idea/devin_chat_dag.py",
-        function="process",
-        invocation="run_streaming",
-        classification="direct_cli_bypass",
-        live_status="live",
-        owner="Devin chat DAG",
-        notes="Streaming ideation follow-through bypass around the canonical seam.",
-        tests=("tests/area10_process_pipeline/test_df2_proc_1002_ideation_intake_dag_red.py",),
-    ),
+    # Devin chat_dag entries removed — devin module is gone (1-line shim only)
+    # Devin chat_dag entries removed — devin module is gone (1-line shim only)
     InventoryRow(
         id="idea.ideation_enrichment.handle_ideation_enrichment_task",
         file="src/devflow_engine/idea/ideation_enrichment.py",

{devflow_engine-1.1.25 → devflow_engine-1.1.27}/src/devflow_engine/cli/app.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
-import base64
 import ast
 import json
 import logging
 import io
 import os
 import re
-import shutil
 import sqlite3
 import subprocess
 import sys
 import tempfile
 import time
 import shutil
+import uuid
 from contextlib import redirect_stderr, redirect_stdout
 from datetime import datetime, timezone
 from hashlib import sha256
@@ -502,35 +501,11 @@ def _provision_python_backend_template(dest: Path, *, template: str, project_nam
         if d.exists() and not any(d.iterdir()):
             d.rmdir()
 
-    # Pre-initialize git with a non-Nuosis origin so the Nuosis script's
-    # template-repository check (which rejects Nuosis/clarify as origin)
-    # passes and skips the interactive GitHub repo creation step.
-    if not (dest / ".git").exists():
-        _run_git_command(["git", "init"], cwd=dest)
-    nuosis_fake_remote = f"git@github.com:Nuosis/{slug}.git"
-    result_check = subprocess.run(
-        ["git", "remote", "get-url", "origin"],
-        capture_output=True, text=True, cwd=dest,
-    )
-    if result_check.returncode != 0:
-        subprocess.run(["git", "remote", "add", "origin", nuosis_fake_remote], cwd=dest, check=True)
-    else:
-        subprocess.run(["git", "remote", "set-url", "origin", nuosis_fake_remote], cwd=dest, check=True)
-
-    # Fetch Nuosis provision script from GitHub and run it in --project-dir mode
-    nuosis_script = Path(tempfile.gettempdir()) / "nuosis_provision_from_template.py"
-    fetch_result = subprocess.run(
-        ["gh", "api", "repos/Nuosis/clarify/contents/scripts/provision_from_template.py", "--jq", ".content"],
-        capture_output=True, text=True, check=True,
-    )
-    nuosis_script.write_text(base64.b64decode(fetch_result.stdout).decode(), encoding="utf-8")
-    nuosis_script.chmod(0o755)
-
     with tempfile.TemporaryDirectory(prefix="devflow-backend-provision-") as temp_dir:
-        script_copy = Path(temp_dir) / "provision_from_template.py"
-        shutil.copy2(nuosis_script, script_copy)
+        script_copy = Path(temp_dir) / source_script.name
+        shutil.copy2(source_script, script_copy)
         result = subprocess.run(
-            [sys.executable, str(script_copy), "--project-dir", str(dest.resolve()), "--yes"],
+            [sys.executable, str(script_copy), "--dest", str(dest.resolve()), "--project-name", project_name],
             capture_output=True, text=True, check=False,
             cwd=dest,
         )
@@ -683,6 +658,55 @@ def _materialize_repo_template(dest: Path, *, template: str | None, project_name
     _run_git_command(["git", "init"], cwd=dest)
 
 
+def _synthesize_import_story_docs(repo_root: Path, *, owner: str, repo: str) -> None:
+    story_id = "US-IMPORT-001"
+    story_uuid = str(uuid.uuid5(uuid.NAMESPACE_URL, f"devflow-import:{owner}/{repo}:bootstrap-story"))
+    story_root = repo_root / "ai_docs" / "context" / "v2" / "project_docs" / "user_stories" / "import_bootstrap"
+    existing_story_docs = list(story_root.rglob("*.md")) if story_root.exists() else []
+    if not existing_story_docs:
+        _write_repo_file(
+            story_root / "US-IMPORT-001_import-bootstrap.md",
+            "\n".join(
+                [
+                    "# US-IMPORT-001 Import bootstrap story",
+                    "",
+                    f"- story_id: {story_id}",
+                    f"- story_uuid: {story_uuid}",
+                    "- plane: ops",
+                    "",
+                    "## User Story",
+                    "",
+                    f"As a DevFlow operator, I want the imported `{owner}/{repo}` repository to have a canonical first story placeholder so implementation planning has a durable story-doc root.",
+                    "",
+                    "## Acceptance Criteria",
+                    "",
+                    "- Canonical user-story docs exist under `ai_docs/context/v2/project_docs/user_stories`.",
+                    "- Missing behavioral coverage is represented by an explicit red test stub.",
+                    "",
+                ]
+            ),
+        )
+
+    test_root = repo_root / "tests" / "import_bootstrap"
+    existing_red_tests = list(test_root.rglob("test_*red*.py")) if test_root.exists() else []
+    if not existing_red_tests:
+        _write_repo_file(
+            test_root / "test_import_bootstrap_red.py",
+            "\n".join(
+                [
+                    "import pytest",
+                    "",
+                    f'@pytest.mark.story_id("{story_id}")',
+                    f'@pytest.mark.story_uuid("{story_uuid}")',
+                    "def test_import_bootstrap_story_needs_real_acceptance_coverage():",
+                    "    # TODO: replace this bootstrap stub with behavior-specific red coverage.",
+                    "    assert False",
+                    "",
+                ]
+            ),
+        )
+
+
 def _bootstrap_repo_local(repo_root: Path, *, project_name: str | None = None, imported: bool = False) -> None:
     dv = repo_root / ".devflow"
     dv.mkdir(parents=True, exist_ok=True)
@@ -712,10 +736,24 @@ def _create_new_project_repo(*, project_name: str, template: str | None) -> Path
 def _resolve_registered_repo_root(entry: dict[str, object], *, selector: str) -> tuple[str, Path]:
     project_id = str(entry.get("project_id") or "").strip()
     repo_root_raw = str(entry.get("repo_root") or "").strip()
-    if not project_id or not repo_root_raw:
+    if not project_id:
         raise ValueError(f"Registered project is missing repo_root for selector={selector}")
-    repo_root = Path(repo_root_raw).expanduser().resolve()
-    return project_id, repo_root
+    if repo_root_raw:
+        repo_root = Path(repo_root_raw).expanduser().resolve()
+        return project_id, repo_root
+    workspace_raw = str(entry.get("workspace_path") or "").strip()
+    if not workspace_raw:
+        raise ValueError(f"Registered project is missing repo_root for selector={selector}")
+    workspace = Path(workspace_raw).expanduser().resolve()
+    repo_name = str(entry.get("repo") or "").strip()
+    candidates = [workspace]
+    if repo_name:
+        candidates.append(workspace / repo_name)
+    candidates.append(workspace / "repo")
+    for candidate in candidates:
+        if (candidate / ".git").exists() or (candidate / ".devflow" / "execution.sqlite").exists():
+            return project_id, candidate
+    raise ValueError(f"Registered project repo_root does not exist for selector={selector}: {workspace}")
 
 
 def _integrate_prepare_inline(*, idea_id: str, rr: Path) -> Path:
@@ -1533,6 +1571,7 @@ def project_init(
 def project_import(
     repo_spec: str = typer.Argument(..., help="GitHub owner/repo, GitHub URL, or destination directory when using --init"),
     init: str | None = typer.Option(None, "--init", help="Initialize a new blank repo from a template: python|typescript|monorepo-py-ts|next|react-native"),
+    synthesize_stories: bool = typer.Option(False, "--synthesize-stories", help="Create bootstrap story docs and red test stubs when an imported repo has none"),
     supabase_project_id: str | None = typer.Option(None, "--supabase-project-id", hidden=True),
 ) -> None:
     """Import a project into DevFlow.
@@ -1609,6 +1648,8 @@ def project_import(
             raise typer.Exit(code=2)
 
     _bootstrap_repo_local(repo_root)
+    if synthesize_stories:
+        _synthesize_import_story_docs(repo_root, owner=owner, repo=repo)
     result = run_project_registration_dag(
         repo_root=repo_root,
         workspace_path=repo_root,
@@ -2551,7 +2592,7 @@ def worker_retry_idea_creation(
 
 @config_app.command("get")
 def config_get(
-    key: str | None = typer.Option(None, help="Config key (omit to list all)"),
+    key: str | None = typer.Argument(None, help="Config key (omit to list all)"),
     project_id: str | None = typer.Option(None, "--project", help="Project id"),
     explain: bool = typer.Option(False, "--explain", help="Explain where the value came from"),
     json_out: bool = typer.Option(False, "--json", help="Emit JSON"),
@@ -3008,24 +3049,38 @@ def story_execute(
             message="story not found",
             details={"story_id": story_id},
         )
+        store.mark_run_finished(run_id=run.run_id, status="failed")
         raise typer.Exit(code=2)
 
     # Minimal routing: any registered story executes via the process DAG.
     # (Implementation + Review; currently imperative, not GenAI workflow.)
-    from ..process.dag import run_process_dag
-
-    pres = run_process_dag(repo_root=repo_root, store=store, story=s)
-    exit_code, msg = pres.exit_code, pres.message
-    store.add_event(
-        run_id=run.run_id,
-        level="INFO",
-        message="executed story",
-        payload={"story_id": story_id, "exit_code": exit_code},
-    )
-    if msg:
-        # Keep user-facing output deterministic.
-        sys.stdout.write(msg)
-    raise typer.Exit(code=exit_code)
+    try:
+        pres = run_process_dag(repo_root=repo_root, store=store, story=s)
+        exit_code, msg = pres.exit_code, pres.message
+        store.add_event(
+            run_id=run.run_id,
+            level="INFO",
+            message="executed story",
+            payload={"story_id": story_id, "exit_code": exit_code},
+        )
+        if exit_code == 0:
+            store.update_story_status(story_id=story_id, status="implemented")
+        store.mark_run_finished(run_id=run.run_id, status="succeeded" if exit_code == 0 else "failed")
+        if msg:
+            # Keep user-facing output deterministic.
+            sys.stdout.write(msg)
+        raise typer.Exit(code=exit_code)
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        store.add_error(
+            run_id=run.run_id,
+            source="story.execute",
+            message="story execution crashed",
+            details={"story_id": story_id, "error": str(exc), "error_type": exc.__class__.__name__},
+        )
+        store.mark_run_finished(run_id=run.run_id, status="failed")
+        raise
 
 
 @plan_app.command("analyze")
@@ -5725,30 +5780,39 @@ def error_solve_runtime(
         ).fetchone()
     resolved_project_id = None if error_row is None else error_row["project_id"]
     if resolved_project_id is None:
+        if not repro_command and not runtime_context:
+            now = int(time.time())
+            with store._connect() as conn:
+                conn.execute(
+                    "UPDATE error_tasks SET status='blocked', updated_at=? WHERE error_task_id=?",
+                    (now, error_task_id),
+                )
+            store.add_event(
+                run_id=run.run_id,
+                level="warning",
+                message="Runtime error dropped because no local DevFlow project_id could be resolved",
+                payload={"error_task_id": error_task_id, "fingerprint": fingerprint, "reason": "unresolved_project_id"},
+            )
+            store.mark_run_finished(run_id=run.run_id, status="failed")
+            out = {
+                "success": True,
+                "error_task_id": error_task_id,
+                "context_path": str(repo_root / ".devflow" / "errors" / "logs" / error_task_id / "context.json"),
+                "result": {"success": True, "error_task_id": error_task_id, "outcome": "blocked", "reason": "unresolved_project_id"},
+            }
+            if json_out:
+                sys.stdout.write(json.dumps(out, sort_keys=True) + "\n")
+                return
+            console.print(out)
+            return
+        resolved_project_id = "local_runtime"
         now = int(time.time())
         with store._connect() as conn:
             conn.execute(
-                "UPDATE error_tasks SET status='blocked', updated_at=? WHERE error_task_id=?",
-                (now, error_task_id),
+                "UPDATE error_tasks SET project_id=?, updated_at=? WHERE error_task_id=?",
+                (resolved_project_id, now, error_task_id),
             )
-        store.add_event(
-            run_id=run.run_id,
-            level="warning",
-            message="Runtime error dropped because no local DevFlow project_id could be resolved",
-            payload={"error_task_id": error_task_id, "fingerprint": fingerprint, "reason": "unresolved_project_id"},
-        )
-        store.mark_run_finished(run_id=run.run_id, status="failed")
-        out = {
-            "success": True,
-            "error_task_id": error_task_id,
-            "context_path": str(repo_root / ".devflow" / "errors" / "logs" / error_task_id / "context.json"),
-            "result": {"success": True, "error_task_id": error_task_id, "outcome": "blocked", "reason": "unresolved_project_id"},
-        }
-        if json_out:
-            sys.stdout.write(json.dumps(out, sort_keys=True) + "\n")
-            return
-        console.print(out)
-        return
+        store.add_event(run_id=run.run_id, level="INFO", message="Runtime error using local runtime project scope", payload={"error_task_id": error_task_id, "fingerprint": fingerprint, "project_id": resolved_project_id})
 
     def build_observability_fn(ctx: dict[str, Any]) -> dict[str, Any]:
         runtime_ctx = ctx.get("runtimeContext") if isinstance(ctx, dict) else None

{devflow_engine-1.1.25 → devflow_engine-1.1.27}/src/devflow_engine/devflow_event_worker.py

@@ -504,13 +504,68 @@ class DevflowEventWorkerService:
                     "error": str(exc),
                 })
 
+        # Stage and commit the added source docs (and any DDR output) into the
+        # project repo. Mirrors the git plane owned by implementation/dag.py:
+        # `git add -A` + `git commit --no-verify`, with an empty-diff guard so
+        # re-uploading identical bytes does not create an empty commit.
+        committed = False
+        commit_sha: str | None = None
+        commit_error: str | None = None
+        try:
+            subprocess.run(
+                ["git", "add", "-A"],
+                cwd=str(repo_root),
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            staged = subprocess.run(
+                ["git", "diff", "--cached", "--name-only"],
+                cwd=str(repo_root),
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            staged_paths = [line for line in (staged.stdout or "").splitlines() if line.strip()]
+            if staged_paths:
+                event_ref = str(event.get("id") or event.get("run_id") or "unknown")
+                message = (
+                    f"source docs: add {len(added_files)} file(s)"
+                    f"\n\nDevFlow-Event: {event_ref}\n"
+                )
+                commit = subprocess.run(
+                    ["git", "commit", "--no-verify", "-m", message],
+                    cwd=str(repo_root),
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                )
+                if commit.returncode == 0:
+                    committed = True
+                    rev = subprocess.run(
+                        ["git", "rev-parse", "HEAD"],
+                        cwd=str(repo_root),
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                    )
+                    commit_sha = (rev.stdout or "").strip() or None
+                else:
+                    commit_error = (commit.stderr or commit.stdout or "git commit failed").strip()[-500:]
+        except Exception as exc:  # never fail the upload because the commit failed
+            commit_error = str(exc)
+
         result_data = {
             "source_mode": source_mode,
             "added_count": len(added_files),
             "added_files": added_files,
             "source_docs_root": str(source_docs_root),
             "local_repo_root": str(repo_root),
+            "committed": committed,
+            "commit_sha": commit_sha,
         }
+        if commit_error:
+            result_data["commit_error"] = commit_error
         if ddr_results:
             result_data["ddr_analysis"] = ddr_results if len(ddr_results) > 1 else ddr_results[0]
         return result_data