ouroboros-ai 0.38.3.dev136__tar.gz → 0.38.3.dev137__tar.gz

{ouroboros_ai-0.38.3.dev136 → ouroboros_ai-0.38.3.dev137}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.38.3.dev136
+Version: 0.38.3.dev137
 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.38.3.dev136 → ouroboros_ai-0.38.3.dev137}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.38.3.dev136'
-__version_tuple__ = version_tuple = (0, 38, 3, 'dev136')
+__version__ = version = '0.38.3.dev137'
+__version_tuple__ = version_tuple = (0, 38, 3, 'dev137')
 
 __commit_id__ = commit_id = None

ouroboros_ai-0.38.3.dev137/src/ouroboros/auto/execution_acceptance.py

@@ -0,0 +1,64 @@
+"""Execution-facing acceptance criteria normalization for auto-generated Seeds."""
+
+from __future__ import annotations
+
+from ouroboros.core.seed import Seed
+
+_AUTO_WRAPPER_CRITERIA = frozenset(
+    {
+        "`ooo auto` is dispatched to the mcp tool `ouroboros_auto`",
+        "`ooo auto` is handled by ouroboros auto/mcp, not plain text",
+        "final report includes auto session id, seed id, seed path, and test result",
+        "final report includes auto session id, seed id, files changed, exact test command, and test result",
+    }
+)
+
+_OBSERVATION_CONTEXT_REQUIRED = (
+    "hello_auto.py",
+    "tests/test_hello_auto.py",
+)
+
+_OBSERVATION_CONTEXT_ALTERNATES = (
+    "ooo auto",
+    "ouroboros_auto",
+)
+
+
+def normalize_execution_acceptance(seed: Seed) -> Seed:
+    """Remove auto-observation/reporting criteria from execution Seeds.
+
+    Auto observation prompts can include wrapper/reporting duties such as
+    dispatch confirmation and final auto-session metadata. Those should not be
+    handed to the execution worker as implementation ACs. To avoid mutating
+    product requirements, only strip exact known wrapper criteria when the Seed
+    itself carries auto-wrapper context.
+    """
+    criteria = tuple(ac for ac in seed.acceptance_criteria if ac and ac.strip())
+    if not criteria or not _has_auto_wrapper_context(seed.goal, criteria):
+        return seed
+
+    filtered = tuple(ac for ac in criteria if not is_auto_reporting_acceptance_criterion(ac))
+    if not filtered or filtered == criteria:
+        return seed
+    return seed.model_copy(update={"acceptance_criteria": filtered})
+
+
+def is_auto_reporting_acceptance_criterion(criterion: str) -> bool:
+    """Return true only for exact known auto wrapper/report-only criteria."""
+    return _criterion_key(criterion) in _AUTO_WRAPPER_CRITERIA
+
+
+def has_auto_wrapper_context(text: str) -> bool:
+    """Return true only for the known hello_auto observation prompt shape."""
+    lowered = text.casefold()
+    return all(marker in lowered for marker in _OBSERVATION_CONTEXT_REQUIRED) and any(
+        marker in lowered for marker in _OBSERVATION_CONTEXT_ALTERNATES
+    )
+
+
+def _has_auto_wrapper_context(goal: str, criteria: tuple[str, ...]) -> bool:
+    return has_auto_wrapper_context("\n".join((goal, *criteria)))
+
+
+def _criterion_key(criterion: str) -> str:
+    return " ".join(criterion.casefold().strip().rstrip(".").split())

{ouroboros_ai-0.38.3.dev136 → ouroboros_ai-0.38.3.dev137}/src/ouroboros/auto/pipeline.py

@@ -15,6 +15,7 @@ from ouroboros.auto.adapters import EvaluateResult, LateralResult
 from ouroboros.auto.answerer import AutoAnswerer
 from ouroboros.auto.blocker_attribution import record_authoring_backend
 from ouroboros.auto.domain_profile import DEFAULT_REGISTRY
+from ouroboros.auto.execution_acceptance import normalize_execution_acceptance
 from ouroboros.auto.grading import GradeGate, deterministic_floor
 from ouroboros.auto.handoff_contract import (
     IDEMPOTENCY_KEY_FIELD,
@@ -549,6 +550,7 @@ class AutoPipeline:
                     )
                     self._save(state)
                     return self._result(state, ledger, blocker=state.last_error)
+                seed = self._normalize_execution_seed(state, seed)
                 state.transition(AutoPhase.REVIEW, "resuming review from persisted Seed")
                 self._save(state)
             else:
@@ -581,6 +583,7 @@ class AutoPipeline:
                                 ),
                             }
                         )
+                    seed = normalize_execution_acceptance(seed)
                     state.seed_id = seed.metadata.seed_id
                     state.seed_artifact = seed.to_dict()
                     state.seed_origin = SeedOrigin.AUTO_PIPELINE
@@ -628,6 +631,7 @@ class AutoPipeline:
                 )
                 self._save(state)
                 return self._result(state, ledger, blocker=state.last_error)
+            seed = self._normalize_execution_seed(state, seed)
         elif self.seed_loader is not None and state.seed_path:
             seed = self._load_seed(state, state.seed_path)
             if seed is None:
@@ -745,6 +749,7 @@ class AutoPipeline:
                     asyncio.to_thread(repairer.converge, seed, **converge_kwargs),
                     timeout=bounded_repair_timeout,
                 )
+                seed = normalize_execution_acceptance(seed)
             except TimeoutError:
                 cancel_event.set()
                 if self._enforce_deadline(state):
@@ -2161,7 +2166,7 @@ class AutoPipeline:
             return await self._poll_ralph_job(state, ledger, seed, review=review)
 
         if not state.ralph_job_id and state.ralph_lineage_id and self.ralph_starter is not None:
-            seed = Seed.from_dict(state.seed_artifact)
+            seed = self._normalize_execution_seed(state, Seed.from_dict(state.seed_artifact))
             return await self._handoff_to_ralph(
                 state,
                 ledger,
@@ -2446,6 +2451,15 @@ class AutoPipeline:
         self._save(state)
         return True
 
+    def _normalize_execution_seed(
+        self, state: AutoPipelineState, seed: Seed, *, persist: bool = True
+    ) -> Seed:
+        normalized = normalize_execution_acceptance(seed)
+        if normalized is not seed and persist:
+            state.seed_artifact = normalized.to_dict()
+            self._save(state)
+        return normalized
+
     def _load_seed(self, state: AutoPipelineState, seed_path: str) -> Seed | None:
         if self.seed_loader is None:
             state.mark_failed("seed loader is not configured", tool_name="seed_loader")
@@ -2473,6 +2487,7 @@ class AutoPipeline:
         # resumed sessions. Existing non-default values are preserved.
         if state.seed_origin is SeedOrigin.NONE:
             state.seed_origin = SeedOrigin.AUTO_PIPELINE
+        seed = self._normalize_execution_seed(state, seed, persist=False)
         state.seed_id = seed.metadata.seed_id
         state.seed_artifact = seed.to_dict()
         return seed

{ouroboros_ai-0.38.3.dev136 → ouroboros_ai-0.38.3.dev137}/src/ouroboros/mcp/tools/auto_handler.py

@@ -28,6 +28,10 @@ from ouroboros.auto.answerer import (
     AutoAnswerContext,
     risky_user_preference_blocker_for,
 )
+from ouroboros.auto.execution_acceptance import (
+    has_auto_wrapper_context,
+    is_auto_reporting_acceptance_criterion,
+)
 from ouroboros.auto.interview_driver import AutoInterviewDriver
 from ouroboros.auto.ledger import (
     REQUIRED_SECTIONS,
@@ -1520,7 +1524,9 @@ def _derive_goal_user_preferences(goal: str) -> dict[str, str]:
 
     success = _section_text(sections, "success criteria", "acceptance criteria")
     if success:
-        preferences["acceptance_criteria"] = success
+        execution_success = _execution_success_criteria(success, context_text=goal)
+        if execution_success:
+            preferences["acceptance_criteria"] = execution_success
 
     outputs = _section_text(sections, "outputs", "deliverables")
     if outputs:
@@ -1599,6 +1605,16 @@ def _section_text(sections: dict[str, list[str]], *names: str) -> str:
     return "\n".join(dict.fromkeys(value for value in values if value.strip()))
 
 
+def _execution_success_criteria(text: str, *, context_text: str = "") -> str:
+    strip_auto_wrapper = has_auto_wrapper_context("\n".join((context_text, text)))
+    lines = [
+        line
+        for line in (_clean_prompt_line(raw) for raw in text.splitlines())
+        if line and not (strip_auto_wrapper and is_auto_reporting_acceptance_criterion(line))
+    ]
+    return "\n".join(dict.fromkeys(lines))
+
+
 def _matching_lines(text: str, needles: tuple[str, ...]) -> list[str]:
     matches: list[str] = []
     for line in text.splitlines():

ouroboros_ai-0.38.3.dev137/tests/unit/auto/test_execution_acceptance.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from ouroboros.auto.execution_acceptance import normalize_execution_acceptance
+from ouroboros.core.seed import (
+    EvaluationPrinciple,
+    ExitCondition,
+    OntologyField,
+    OntologySchema,
+    Seed,
+    SeedMetadata,
+)
+
+
+def _seed(*criteria: str) -> Seed:
+    return Seed(
+        goal="Verify ooo auto with a minimal coding task",
+        constraints=("Only edit hello_auto.py and tests/test_hello_auto.py",),
+        acceptance_criteria=criteria,
+        ontology_schema=OntologySchema(
+            name="HelloAuto",
+            description="Minimal coding task",
+            fields=(OntologyField(name="file", field_type="string", description="File"),),
+        ),
+        evaluation_principles=(
+            EvaluationPrinciple(name="testability", description="Runnable tests pass"),
+        ),
+        exit_conditions=(
+            ExitCondition(
+                name="verified",
+                description="Targeted test passes",
+                evaluation_criteria="All execution criteria pass",
+            ),
+        ),
+        metadata=SeedMetadata(seed_id="seed_test", ambiguity_score=0.1),
+    )
+
+
+def test_normalize_execution_acceptance_drops_auto_report_criteria() -> None:
+    seed = _seed(
+        "`ooo auto` is dispatched to the MCP tool `ouroboros_auto`.",
+        "Manual fallback is not used.",
+        "`hello_auto.py` defines `hello_auto()` returning exactly `hello from ooo auto`.",
+        "`tests/test_hello_auto.py` imports `hello_auto` and asserts the exact return value.",
+        "The exact command `uv run pytest tests/test_hello_auto.py` passes.",
+        "Final report includes auto session id, seed id, seed path, and test result.",
+    )
+
+    normalized = normalize_execution_acceptance(seed)
+
+    assert normalized.acceptance_criteria == (
+        "Manual fallback is not used.",
+        "`hello_auto.py` defines `hello_auto()` returning exactly `hello from ooo auto`.",
+        "`tests/test_hello_auto.py` imports `hello_auto` and asserts the exact return value.",
+        "The exact command `uv run pytest tests/test_hello_auto.py` passes.",
+    )
+
+
+def test_normalize_execution_acceptance_keeps_original_when_filter_would_empty() -> None:
+    seed = _seed("Final report includes auto session id and seed id.")
+
+    assert normalize_execution_acceptance(seed) is seed
+
+
+def test_normalize_execution_acceptance_preserves_mixed_non_keyword_requirements() -> None:
+    seed = _seed(
+        "`foo.py` exists.",
+        "CLI exits 2 on invalid flags.",
+        "HTTP 400 responses include a machine-readable error code.",
+        "JSON output matches the documented schema.",
+        "Final report includes auto session id and seed path.",
+    )
+
+    normalized = normalize_execution_acceptance(seed)
+
+    assert normalized.acceptance_criteria == (
+        "`foo.py` exists.",
+        "CLI exits 2 on invalid flags.",
+        "HTTP 400 responses include a machine-readable error code.",
+        "JSON output matches the documented schema.",
+        "Final report includes auto session id and seed path.",
+    )
+
+
+def test_normalize_execution_acceptance_preserves_expected_ooo_auto_output() -> None:
+    seed = _seed(
+        "The command prints exactly `hello from ooo auto`.",
+        "Manual fallback is not used.",
+    )
+
+    normalized = normalize_execution_acceptance(seed)
+
+    assert normalized.acceptance_criteria == (
+        "The command prints exactly `hello from ooo auto`.",
+        "Manual fallback is not used.",
+    )
+
+
+def test_normalize_execution_acceptance_preserves_product_final_report_and_fallback() -> None:
+    seed = _seed(
+        "Implement a manual fallback mode for offline users.",
+        "The final report endpoint includes the session id field.",
+        "The final report endpoint includes seed id and seed path.",
+        "Previous blocker history is visible in the admin UI.",
+        "Persist last_question for resumed interviews.",
+        "Manual fallback is not used.",
+    ).model_copy(update={"goal": "Build a reporting API with fallback controls"})
+
+    normalized = normalize_execution_acceptance(seed)
+
+    assert normalized.acceptance_criteria == (
+        "Implement a manual fallback mode for offline users.",
+        "The final report endpoint includes the session id field.",
+        "The final report endpoint includes seed id and seed path.",
+        "Previous blocker history is visible in the admin UI.",
+        "Persist last_question for resumed interviews.",
+        "Manual fallback is not used.",
+    )
+
+
+def test_normalize_execution_acceptance_preserves_exact_product_metadata_requirement() -> None:
+    seed = _seed(
+        "Final report includes auto session id, seed id, seed path, and test result.",
+    ).model_copy(update={"goal": "Build a product final-report endpoint"})
+
+    assert normalize_execution_acceptance(seed) is seed

{ouroboros_ai-0.38.3.dev136 → ouroboros_ai-0.38.3.dev137}/tests/unit/auto/test_interview_pipeline.py

@@ -3771,3 +3771,43 @@ async def test_convergence_contract_stalled_generic_followups_report_actionable_
     open_gaps = ledger.open_gaps()
     assert open_gaps, "stalled generic loop must leave at least one open required gap"
     assert any(section in blocker for section in open_gaps)
+
+
+@pytest.mark.asyncio
+async def test_pipeline_normalizes_persisted_seed_artifact_on_resume(tmp_path) -> None:
+    async def start(goal: str, cwd: str) -> InterviewTurn:  # noqa: ARG001
+        raise AssertionError("resume with seed_artifact should not interview")
+
+    async def answer(session_id: str, text: str) -> InterviewTurn:  # noqa: ARG001
+        raise AssertionError("resume with seed_artifact should not answer")
+
+    async def generate_seed(session_id: str) -> Seed:  # noqa: ARG001
+        raise AssertionError("resume with seed_artifact should not generate")
+
+    seed = _seed(
+        ac=(
+            "`hello_auto.py` exists.",
+            "`tests/test_hello_auto.py` exists.",
+            "Final report includes auto session id, seed id, seed path, and test result.",
+            "CLI exits 2 on invalid flags.",
+        )
+    ).model_copy(update={"goal": "Verify current ooo auto can create hello_auto.py."})
+    state = AutoPipelineState(goal="Build a CLI", cwd=str(tmp_path))
+    state.transition(AutoPhase.INTERVIEW, "interview")
+    state.transition(AutoPhase.SEED_GENERATION, "seed generated")
+    state.transition(AutoPhase.REVIEW, "resume review")
+    state.seed_artifact = seed.to_dict()
+    state.seed_id = seed.metadata.seed_id
+    ledger = SeedDraftLedger.from_goal(state.goal)
+    _fill_ready(ledger)
+    state.ledger = ledger.to_dict()
+    driver = AutoInterviewDriver(FunctionInterviewBackend(start, answer), store=AutoStore(tmp_path))
+    pipeline = AutoPipeline(driver, generate_seed, store=AutoStore(tmp_path), skip_run=True)
+
+    result = await pipeline.run(state)
+
+    assert result.status == "complete"
+    resumed_seed = Seed.from_dict(state.seed_artifact)
+    criteria_text = "\n".join(resumed_seed.acceptance_criteria)
+    assert "Final report includes auto session id" not in criteria_text
+    assert "CLI exits 2 on invalid flags" in criteria_text

{ouroboros_ai-0.38.3.dev136 → ouroboros_ai-0.38.3.dev137}/tests/unit/mcp/tools/test_auto_interview_construction.py

@@ -226,6 +226,8 @@ def test_structured_auto_goal_seeds_required_ledger_sections() -> None:
     assert "runtime_context" in summary["evidence_backed_sections"]
     assert "constraints" in summary["evidence_backed_sections"]
     assert "non_goals" in summary["evidence_backed_sections"]
+    assert "Final report" not in preferences["acceptance_criteria"]
+    assert "`hello_auto.py` exists" in preferences["acceptance_criteria"]
 
 
 def test_structured_auto_goal_does_not_preconfirm_risky_preference() -> None:
@@ -246,7 +248,6 @@ Success criteria:
     preferences = _derive_goal_user_preferences(risky_goal)
 
     assert "outputs" in preferences
-    assert "acceptance_criteria" in preferences
     ledger = _seed_initial_ledger_from_user_preferences(risky_goal, preferences)
 
     assert "outputs" not in ledger.summary()["evidence_backed_sections"]
@@ -269,6 +270,78 @@ Implementation:
     assert "inputs" not in preferences
 
 
+def test_structured_auto_goal_filters_report_only_success_criteria() -> None:
+    preferences = _derive_goal_user_preferences(_OBSERVATION_GOAL)
+
+    assert "acceptance_criteria" in preferences
+    assert "manual fallback" not in preferences["acceptance_criteria"].casefold()
+    assert "seed id" not in preferences["acceptance_criteria"].casefold()
+    assert "uv run pytest tests/test_hello_auto.py" in preferences["acceptance_criteria"]
+
+
+def test_structured_auto_goal_preserves_non_allowlisted_execution_criteria() -> None:
+    goal = """
+Goal:
+Build a CLI validation endpoint.
+
+Success criteria:
+- `validator.py` exists.
+- CLI exits 2 on invalid flags.
+- HTTP 400 responses include a machine-readable error code.
+- JSON output matches the documented schema.
+- The command prints exactly `hello from ooo auto`.
+- Final report includes auto session id, seed id, seed path, and test result.
+"""
+
+    preferences = _derive_goal_user_preferences(goal)
+
+    assert preferences["acceptance_criteria"] == (
+        "`validator.py` exists.\n"
+        "CLI exits 2 on invalid flags.\n"
+        "HTTP 400 responses include a machine-readable error code.\n"
+        "JSON output matches the documented schema.\n"
+        "The command prints exactly `hello from ooo auto`.\n"
+        "Final report includes auto session id, seed id, seed path, and test result."
+    )
+
+
+def test_structured_auto_goal_filters_wrapper_criteria_using_full_prompt_context() -> None:
+    goal = """
+Goal:
+Verify current ooo auto can create hello_auto.py and tests/test_hello_auto.py.
+
+Success criteria:
+- `hello_auto.py` exists.
+- `tests/test_hello_auto.py` exists.
+- Final report includes auto session id, seed id, seed path, and test result.
+
+Important dispatch rule:
+If `ouroboros_auto` is unavailable or interpreted as normal text, stop and report failure.
+"""
+
+    preferences = _derive_goal_user_preferences(goal)
+
+    assert preferences["acceptance_criteria"] == (
+        "`hello_auto.py` exists.\n`tests/test_hello_auto.py` exists."
+    )
+
+
+def test_structured_product_goal_preserves_exact_final_report_metadata_requirement() -> None:
+    goal = """
+Goal:
+Build a product final-report endpoint.
+
+Success criteria:
+- Final report includes auto session id, seed id, seed path, and test result.
+"""
+
+    preferences = _derive_goal_user_preferences(goal)
+
+    assert preferences["acceptance_criteria"] == (
+        "Final report includes auto session id, seed id, seed path, and test result."
+    )
+
+
 def test_resume_preference_override_reseeds_stale_preconfirmed_ledger() -> None:
     """Resume preference overrides must update persisted ledger source of truth."""
     original_preferences = _derive_goal_user_preferences(_OBSERVATION_GOAL)