ouroboros-ai 0.43.3.dev4__tar.gz → 0.43.3.dev6__tar.gz

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.43.3.dev4
+Version: 0.43.3.dev6
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.43.3.dev4'
-__version_tuple__ = version_tuple = (0, 43, 3, 'dev4')
+__version__ = version = '0.43.3.dev6'
+__version_tuple__ = version_tuple = (0, 43, 3, 'dev6')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/src/ouroboros/auto/pipeline.py

@@ -385,6 +385,11 @@ class AutoPipelineResult:
     partial_product: bool = False
     partial_product_reason: str | None = None
     partial_unresolved_slots: tuple[str, ...] = ()
+    # #1509: final-status surfaces must distinguish orchestration state
+    # from artifact state so BLOCKED/FAILED sessions with generated files are
+    # not mistaken for verified completion. Values are intentionally stringly
+    # typed for stable CLI/MCP wire compatibility.
+    artifact_state: str | None = None
 
 
 @dataclass(slots=True)
@@ -4023,7 +4028,7 @@ class AutoPipeline:
         # L1-d / #1171: derive the task class from the standardized ledger
         # and prepend the catalog's default AC template to the Seed.
         inference = derive_domain_from_ledger(ledger)
-        task_class = inference.single
+        task_class = next(iter(inference.classes)) if inference.is_single else None
         if task_class is not None:
             applied = apply_default_ac_template(seed, task_class)
             if applied.injected_ac:
@@ -4099,8 +4104,20 @@ class AutoPipeline:
         # (e.g. on a safety blocker) keeps ``partial_product=False`` so the
         # field cannot be misread as "deadline recovery succeeded".
         partial_product = seed_degraded and state.phase == AutoPhase.COMPLETE
+        result_status = status_override or state.phase.value
+        artifact_state = _artifact_state_for_result(
+            status=result_status,
+            phase=state.phase,
+            seed_path=state.seed_path,
+            execution_id=state.execution_id,
+            job_id=state.job_id,
+            run_session_id=state.run_session_id,
+            run_handoff_status=state.run_handoff_status,
+            partial_product=partial_product,
+            product_verified=_has_verified_product_completion(state),
+        )
         return AutoPipelineResult(
-            status=status_override or state.phase.value,
+            status=result_status,
             auto_session_id=state.auto_session_id,
             phase=state.phase.value,
             grade=review.grade_result.grade.value if review else state.last_grade,
@@ -4157,6 +4174,7 @@ class AutoPipeline:
             partial_product=partial_product,
             partial_product_reason=partial_product_reason,
             partial_unresolved_slots=partial_unresolved_slots,
+            artifact_state=artifact_state,
         )
 
     def _checkpoint_final_commit(self, state: AutoPipelineState) -> None:
@@ -4339,6 +4357,61 @@ class AutoPipeline:
             pass
 
 
+def _artifact_state_for_result(
+    *,
+    status: str,
+    phase: AutoPhase,
+    seed_path: str | None,
+    execution_id: str | None,
+    job_id: str | None,
+    run_session_id: str | None,
+    partial_product: bool,
+    run_handoff_status: str | None = None,
+    product_verified: bool = False,
+) -> str:
+    """Classify the generated-artifact outcome separately from orchestration.
+
+    ``status`` remains the authoritative orchestration state. This companion
+    value prevents final renderers from implying completion when a BLOCKED or
+    FAILED run still left useful generated files behind.
+    """
+
+    has_generated_artifact = bool(seed_path or execution_id or job_id or run_session_id)
+    if status in {AutoPhase.BLOCKED.value, AutoPhase.FAILED.value}:
+        return "partial_artifact_generated" if has_generated_artifact else status
+    if status == AutoPhase.COMPLETE.value:
+        if partial_product:
+            return "complete_unverified"
+        if product_verified:
+            return "complete_verified"
+        if run_handoff_status == RUN_HANDOFF_STARTED_STATUS:
+            return "complete_unverified"
+        return "complete_verified"
+    if phase in {AutoPhase.BLOCKED, AutoPhase.FAILED}:
+        return "partial_artifact_generated" if has_generated_artifact else phase.value
+    return "artifact_in_progress" if has_generated_artifact else "not_generated"
+
+
+def _has_verified_product_completion(state: AutoPipelineState) -> bool:
+    """Return True when COMPLETE represents a verified product terminal.
+
+    ``run_handoff_status=started`` can persist after a complete-product run moves
+    through Ralph/EVALUATE success. Treat those terminal success signals as
+    stronger evidence than the stale handoff marker so final surfaces do not
+    downgrade verified product completion to handoff-only completion.
+    """
+
+    if state.phase is not AutoPhase.COMPLETE:
+        return False
+    if state.ralph_job_status == "completed":
+        return True
+    if state.last_qa_passed is True:
+        return True
+    if state.complete_product and state.ralph_stop_reason is not None:
+        return True
+    return state.run_handoff_status == "completed"
+
+
 def _mark_invalid_seed_artifact(state: AutoPipelineState, message: str) -> None:
     state.seed_artifact = {}
     # Keep seed_origin consistent with the now-empty seed_artifact: the

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/src/ouroboros/cli/commands/auto.py

@@ -871,6 +871,8 @@ def _print_result(result: AutoPipelineResult, *, show_ledger: bool) -> None:
     console.print(f"Auto session: [cyan]{result.auto_session_id}[/]")
     displayed_status = "run_handoff_started" if handoff_only else result.status
     console.print(f"Status: [bold]{displayed_status}[/]")
+    if result.artifact_state:
+        console.print(f"Artifact state: [bold]{result.artifact_state}[/]")
     if handoff_only:
         console.print(
             "Product status: [yellow]not verified complete; execution is still external/pending[/]"

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/src/ouroboros/mcp/tools/auto_handler.py

@@ -1376,6 +1376,8 @@ def _result_meta(result: AutoPipelineResult) -> dict[str, Any]:
         "job_id": result.job_id,
         "run_session_id": result.run_session_id,
     }
+    if result.artifact_state is not None:
+        meta["artifact_state"] = result.artifact_state
     if handoff_only:
         meta["presentation_status"] = _presentation_status(result)
         meta["product_status"] = "not_verified_complete"
@@ -2171,6 +2173,8 @@ def _format_result(result: AutoPipelineResult) -> str:
         f"Status: {_presentation_status(result)}",
         f"Phase: {result.phase}",
     ]
+    if result.artifact_state:
+        lines.append(f"Artifact state: {result.artifact_state}")
     if handoff_only:
         lines.append("Product status: not verified complete; execution is still external/pending")
     elif result.status == "detached":

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/tests/unit/auto/test_pipeline_task_class_envelope.py

@@ -5,8 +5,8 @@ Asserts:
   is populated when the ledger unambiguously matches a single class.
 - The Seed passed downstream has the catalog's ``default_ac_template``
   prepended to ``acceptance_criteria``.
-- An unmatched ledger applies the safe LIBRARY fallback; an ambiguous
-  ledger leaves ``active_task_class`` as None and AC untouched.
+- Unmatched and ambiguous ledgers leave ``active_task_class`` as None and AC
+  untouched.
 """
 
 from __future__ import annotations
@@ -214,11 +214,7 @@ async def test_envelope_carries_active_task_class_on_single_match(tmp_path) -> N
 
 
 @pytest.mark.asyncio
-async def test_envelope_uses_library_fallback_when_unmatched(tmp_path) -> None:
-    """Unmatched inference applies the L1-b safe LIBRARY fallback instead
-    of silently skipping default AC injection."""
-    profile = TASK_CLASS_CATALOG[TaskClass.LIBRARY]
-
+async def test_envelope_leaves_active_task_class_none_when_unmatched(tmp_path) -> None:
     async def start(goal: str, cwd: str) -> InterviewTurn:  # noqa: ARG001
         return InterviewTurn("What should we verify?", "interview_envelope_unmatched")
 
@@ -248,14 +244,13 @@ async def test_envelope_uses_library_fallback_when_unmatched(tmp_path) -> None:
 
     result = await pipeline.run(state)
 
-    assert result.active_task_class == TaskClass.LIBRARY.value
+    assert result.active_task_class is None
     ac = state.seed_artifact["acceptance_criteria"]
-    for index, expected in enumerate(profile.default_ac_template):
-        # The pipeline may wrap generic/library AC in execution-oriented
-        # phrasing, but it preserves the injected template text as the
-        # original requirement payload.
-        assert expected.removesuffix(".").replace(" are ", " ") in ac[index]
-    assert len(ac) >= len(profile.default_ac_template) + 1
+    library_template_entries = TASK_CLASS_CATALOG[TaskClass.LIBRARY].default_ac_template
+    for template_entry in library_template_entries:
+        assert template_entry not in ac, (
+            f"unmatched inference must not inject library template entry: {template_entry!r}"
+        )
     assert any("Changed behavior" in item and "tests" in item for item in ac)
 
 

{ouroboros_ai-0.43.3.dev4 → ouroboros_ai-0.43.3.dev6}/tests/unit/auto/test_surface.py

@@ -2602,9 +2602,19 @@ def test_auto_handler_attached_completion_is_not_handoff_started() -> None:
 
 
 def test_auto_handler_meta_and_text_distinguish_handoff_from_product_completion() -> None:
-    from ouroboros.auto.pipeline import AutoPipelineResult
+    from ouroboros.auto.pipeline import AutoPipelineResult, _artifact_state_for_result
     from ouroboros.mcp.tools.auto_handler import _format_result, _result_meta
 
+    artifact_state = _artifact_state_for_result(
+        status="complete",
+        phase=AutoPhase.COMPLETE,
+        seed_path=None,
+        execution_id="exec_123",
+        job_id="job_123",
+        run_session_id=None,
+        run_handoff_status="started",
+        partial_product=False,
+    )
     result = AutoPipelineResult(
         status="complete",
         auto_session_id="auto_handoff",
@@ -2612,6 +2622,7 @@ def test_auto_handler_meta_and_text_distinguish_handoff_from_product_completion(
         run_handoff_status="started",
         job_id="job_123",
         execution_id="exec_123",
+        artifact_state=artifact_state,
     )
 
     meta = _result_meta(result)
@@ -2620,5 +2631,102 @@ def test_auto_handler_meta_and_text_distinguish_handoff_from_product_completion(
     assert meta["status"] == "complete"
     assert meta["presentation_status"] == "run_handoff_started"
     assert meta["product_status"] == "not_verified_complete"
+    assert meta["artifact_state"] == "complete_unverified"
     assert "Status: run_handoff_started" in text
     assert "Product status: not verified complete" in text
+    assert "Artifact state: complete_unverified" in text
+
+
+def test_auto_artifact_state_preserves_verified_ralph_completion_with_stale_handoff() -> None:
+    from ouroboros.auto.pipeline import _artifact_state_for_result
+
+    assert (
+        _artifact_state_for_result(
+            status="complete",
+            phase=AutoPhase.COMPLETE,
+            seed_path="/tmp/seed.yaml",
+            execution_id="exec_123",
+            job_id="job_123",
+            run_session_id=None,
+            run_handoff_status="started",
+            partial_product=False,
+            product_verified=True,
+        )
+        == "complete_verified"
+    )
+
+
+def test_auto_artifact_state_marks_blocked_seed_as_partial_artifact() -> None:
+    from ouroboros.auto.pipeline import _artifact_state_for_result
+
+    assert (
+        _artifact_state_for_result(
+            status="blocked",
+            phase=AutoPhase.BLOCKED,
+            seed_path="/tmp/seed.yaml",
+            execution_id=None,
+            job_id=None,
+            run_session_id=None,
+            run_handoff_status=None,
+            partial_product=False,
+        )
+        == "partial_artifact_generated"
+    )
+
+
+def test_auto_artifact_state_does_not_report_completion_for_pending_interview() -> None:
+    from ouroboros.auto.pipeline import _artifact_state_for_result
+
+    assert (
+        _artifact_state_for_result(
+            status="interview",
+            phase=AutoPhase.INTERVIEW,
+            seed_path=None,
+            execution_id=None,
+            job_id=None,
+            run_session_id=None,
+            run_handoff_status=None,
+            partial_product=False,
+        )
+        == "not_generated"
+    )
+
+
+def test_auto_artifact_state_marks_nonterminal_handles_as_in_progress() -> None:
+    from ouroboros.auto.pipeline import _artifact_state_for_result
+
+    assert (
+        _artifact_state_for_result(
+            status="running",
+            phase=AutoPhase.RUN,
+            seed_path="/tmp/seed.yaml",
+            execution_id="exec-123",
+            job_id=None,
+            run_session_id="run-123",
+            partial_product=False,
+        )
+        == "artifact_in_progress"
+    )
+
+
+def test_auto_handler_surfaces_orchestration_and_artifact_state_for_blocked_result() -> None:
+    from ouroboros.auto.pipeline import AutoPipelineResult
+    from ouroboros.mcp.tools.auto_handler import _format_result, _result_meta
+
+    result = AutoPipelineResult(
+        status="blocked",
+        auto_session_id="auto_blocked_artifact",
+        phase="blocked",
+        seed_path="/tmp/seed.yaml",
+        artifact_state="partial_artifact_generated",
+        blocker="Seed QA timed out",
+    )
+
+    meta = _result_meta(result)
+    text = _format_result(result)
+
+    assert meta["status"] == "blocked"
+    assert meta["artifact_state"] == "partial_artifact_generated"
+    assert "Status: blocked" in text
+    assert "Artifact state: partial_artifact_generated" in text
+    assert "Status: complete" not in text