ouroboros-ai 0.40.1.dev2__tar.gz → 0.40.2.dev1__tar.gz

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "ouroboros",
       "description": "Transform vague ideas into validated seed specifications through Socratic questioning and ontological analysis",
-      "version": "0.40.1",
+      "version": "0.40.2",
       "author": {
         "name": "Q00",
         "email": "jqyu.lee@gmail.com"

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ouroboros",
-  "version": "0.40.1",
+  "version": "0.40.2",
   "description": "Self-improving AI workflow system. Crystallize requirements before execution with Socratic interview, ambiguity scoring, and 3-stage evaluation.",
   "author": {
     "name": "Q00",

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.40.1.dev2
+Version: 0.40.2.dev1
 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.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/docs/README.md

@@ -55,6 +55,7 @@ replayable execution contract on your choice of runtime backend.
 - [Agent OS Kernel Terminology](./contributing/agent-os-kernel-terminology.md) - Locked vocabulary for `AgentRuntimeContext`, `ControlPlane`, `ControlContract`, `Directive`, `ControlBus`, and `IOJournal`
 - [ControlContract](./contributing/control-contract.md) - Control-plane schema, terminality, replay, and idempotency invariants
 - [Testing Guide](./contributing/testing-guide.md) - Writing and running tests
+- [Verifier Evidence Policy](./contributing/verifier-evidence-policy.md) - Core verifier boundary: avoid runner-specific parsers, classify evidence-form mismatches, and preserve anti-fabrication semantics
 - [Key Patterns](./contributing/key-patterns.md) - Result type, immutability, event sourcing, protocols
 - [Findings Registry](./contributing/findings-registry.md) - Documentation audit findings registry
 - [Issue Quality Policy](./contributing/issue-quality-policy.md) - Quality bar for actionable issues and PRD-lite feature requests

ouroboros_ai-0.40.2.dev1/docs/contributing/verifier-evidence-policy.md

@@ -0,0 +1,80 @@
+# Verifier Evidence Policy
+
+This policy governs fixes to the atomic verifier and fat-harness evidence
+boundary.
+
+The core verifier must stay domain- and language-agnostic. It decides whether
+typed evidence is backed by the runtime transcript. It must not grow bespoke
+parsers for each test runner, language ecosystem, framework, or report format.
+
+## Core rule
+
+When valid work appears to be rejected, first classify the failure shape:
+
+| Shape | Meaning | Correct direction |
+| --- | --- | --- |
+| No runtime transcript evidence exists for the claim | The claim may be fabricated. | Keep or use `FABRICATION_SUSPECTED`. |
+| Related runtime work exists, but the evidence form cannot prove the claim | The evidence contract is mismatched. | Use `EVIDENCE_FORM_MISMATCH` with retry guidance. |
+| The evidence needs runner-specific interpretation | The core verifier is the wrong layer. | Add a profile/adapter-level contract or require a runner-agnostic proof form. |
+
+## Do not add runner-specific parsers to core
+
+Avoid fixes that teach `parallel_executor.py` to understand one ecosystem's
+result format, such as JUnit XML, pytest JUnit XML, TAP, Go test JSON, Vitest
+JSON, Maven Surefire XML, or Gradle-specific report layouts.
+
+Those fixes make one stack pass while creating an implicit obligation to support
+every other stack in the same core path. They also make anti-fabrication
+semantics depend on language-specific parsing details that the core verifier
+cannot own consistently.
+
+## Preferred evidence forms
+
+For test commands whose output is filtered or paged, the preferred proof is a
+runner-agnostic command contract:
+
+```sh
+set -o pipefail && <test command> 2>&1 | tail -100
+```
+
+`pipefail` preserves the failing status of the left-hand test command even when
+the right-hand output filter succeeds. Without it, a filtered pipeline is a real
+transcript event but not a clean command proof.
+
+For richer result formats, prefer one of these approaches:
+
+- Emit a typed, runner-neutral proof field from a profile or adapter that owns
+  that runner.
+- Keep the core verdict as `EVIDENCE_FORM_MISMATCH` and retry with clearer
+  evidence.
+- Promote a new cross-runner evidence contract only after it has an explicit
+  design issue and acceptance criteria across multiple ecosystems.
+
+## Failure class semantics
+
+`FABRICATION_SUSPECTED` is reserved for claims with no supporting runtime event
+or artifact reference. It should not be used when the transcript clearly shows
+related work but the evidence shape is contract-incompatible.
+
+`EVIDENCE_FORM_MISMATCH` means:
+
+- related runtime work is visible;
+- the current evidence form cannot prove the typed claim;
+- retrying with a contract-compliant proof form is reasonable;
+- the verifier must still reject the claim until that proof form exists.
+
+This distinction keeps issue triage honest: the implementer did not necessarily
+invent work, but the harness still cannot accept the evidence.
+
+## Review checklist
+
+Before accepting a verifier-evidence fix, ask:
+
+1. Does this add language-, framework-, or runner-specific parsing to core?
+2. Could the same pattern appear in another ecosystem tomorrow?
+3. Is the fix preserving anti-fabrication semantics, or merely making one report
+   format pass?
+4. Would `EVIDENCE_FORM_MISMATCH` plus retry guidance be the correct smaller
+   response?
+5. If structured parsing is required, is it owned by a profile/adapter or a
+   cross-runner evidence contract rather than by the core verifier?

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/skills/setup/SKILL.md

@@ -282,7 +282,7 @@ A backup will be created: CLAUDE.md.bak
 **If "Preview first", show:**
 ````markdown
 <!-- ooo:START -->
-<!-- ooo:VERSION:0.40.1 -->
+<!-- ooo:VERSION:0.40.2 -->
 # Ouroboros — Specification-First AI Development
 
 > Before telling AI what to build, define what should be built.

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.40.1.dev2'
-__version_tuple__ = version_tuple = (0, 40, 1, 'dev2')
+__version__ = version = '0.40.2.dev1'
+__version_tuple__ = version_tuple = (0, 40, 2, 'dev1')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/src/ouroboros/orchestrator/failure_taxonomy.py

@@ -28,6 +28,9 @@ class FailureClass(StrEnum):
     Members:
         EVIDENCE_MISSING: Leaf could not emit a parseable / validated
             evidence record (covers both parse errors and H2 rejections).
+        EVIDENCE_FORM_MISMATCH: Leaf executed related work, but the evidence
+            shape cannot prove it under the contract (for example an
+            unprotected output-filter pipeline for a test command).
         FABRICATION_SUSPECTED: Verifier flagged claims about files,
             symbols, or sources that do not exist. Verifier sets this
             via VerifierVerdict.failure_class.
@@ -43,6 +46,7 @@ class FailureClass(StrEnum):
     """
 
     EVIDENCE_MISSING = "EVIDENCE_MISSING"
+    EVIDENCE_FORM_MISMATCH = "EVIDENCE_FORM_MISMATCH"
     FABRICATION_SUSPECTED = "FABRICATION_SUSPECTED"
     SCOPE_CREEP = "SCOPE_CREEP"
     STALL = "STALL"
@@ -74,6 +78,14 @@ _POLICY_TABLE: dict[FailureClass, RecoveryPolicy] = {
             "verifier feedback already names the missing/rejected fields."
         ),
     ),
+    FailureClass.EVIDENCE_FORM_MISMATCH: RecoveryPolicy(
+        action=RecoveryAction.RETRY,
+        rationale=(
+            "Leaf ran related work, but its evidence shape cannot prove the "
+            "claim; retry with contract-compliant evidence such as pipefail "
+            "for output-filtered test commands."
+        ),
+    ),
     FailureClass.FABRICATION_SUSPECTED: RecoveryPolicy(
         action=RecoveryAction.ESCALATE_MODEL,
         rationale=(

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/src/ouroboros/orchestrator/parallel_executor.py

@@ -692,6 +692,86 @@ def _runtime_messages_support_command_claim(
     return any(_runtime_message_supports_command_claim(value, message) for message in messages)
 
 
+def _runtime_messages_have_masked_test_command_form(
+    value: str,
+    messages: tuple[AgentMessage, ...],
+) -> bool:
+    """Return True when a test command claim matches only after unsafe plumbing.
+
+    This deliberately does NOT prove the command claim. It distinguishes a real
+    transcript shape that failed the evidence contract (for example a test run
+    piped through ``tail`` without ``set -o pipefail``) from a fabrication where
+    no related test command appears at all.
+    """
+    claim_invocation = _test_command_invocation(value)
+    if claim_invocation is None:
+        return False
+    for message in messages:
+        if message.tool_name != "Bash":
+            continue
+        for runtime_command in _runtime_message_command_values(message):
+            if not _has_trailing_output_filter_pipeline(runtime_command):
+                continue
+            runtime_invocation = _test_command_invocation_allowing_output_plumbing(runtime_command)
+            if runtime_invocation is None:
+                continue
+            if runtime_invocation == claim_invocation or runtime_invocation.startswith(
+                claim_invocation + " "
+            ):
+                return True
+    return False
+
+
+def _runtime_messages_have_masked_test_command_for_test_claim(
+    *,
+    value: str,
+    messages: tuple[AgentMessage, ...],
+    task_cwd: str | None,
+) -> bool:
+    """Return True when a rejected test claim depends on masked test output.
+
+    This is diagnostic only. It lets the verifier classify a dependent
+    ``tests_passed`` failure with the same evidence-form mismatch as the
+    rejected ``commands_run`` claim, while still refusing to accept the masked
+    command as proof.
+    """
+    for index, message in enumerate(messages):
+        if message.tool_name != "Bash":
+            continue
+        masked_invocations: list[str] = []
+        for runtime_command in _runtime_message_command_values(message):
+            if not _has_trailing_output_filter_pipeline(runtime_command):
+                continue
+            runtime_invocation = _test_command_invocation_allowing_output_plumbing(runtime_command)
+            if runtime_invocation is not None:
+                masked_invocations.append(runtime_invocation)
+        if not masked_invocations:
+            continue
+
+        chunk = [message]
+        for following in messages[index + 1 :]:
+            if following.tool_name and not _is_tool_result_message(following):
+                break
+            chunk.append(following)
+        if not any(_message_contains_test_success(item) for item in chunk):
+            continue
+        chunk_text = "\n".join(_runtime_message_search_text(item) for item in chunk)
+        chunk_test_proof_text = "\n".join(_runtime_message_test_proof_text(item) for item in chunk)
+        if any(
+            _test_command_targets_claim(
+                command=command,
+                claim=value,
+                chunk_text=chunk_text,
+                chunk_test_proof_text=chunk_test_proof_text,
+                messages=messages,
+                task_cwd=task_cwd,
+            )
+            for command in masked_invocations
+        ):
+            return True
+    return False
+
+
 def _runtime_messages_support_file_claim(
     value: str,
     messages: tuple[AgentMessage, ...],
@@ -936,6 +1016,29 @@ def _test_command_invocation(command: str) -> str | None:
     return _test_invocation_from_shell_body(body)
 
 
+def _test_command_invocation_allowing_output_plumbing(command: str) -> str | None:
+    """Return a test invocation after stripping output plumbing unconditionally.
+
+    This must not be used as command proof. It exists only to classify rejected
+    evidence forms for diagnostics while preserving the #1208 masking guard.
+    """
+    normalized = command.strip().lower()
+    if not normalized:
+        return None
+    direct = _test_invocation_from_prefix(_strip_command_output_plumbing(normalized))
+    if direct is not None:
+        return direct
+    body = _shell_command_body(normalized)
+    if body is None:
+        return None
+    for segment, _pipefail_enabled in _segments_after_safe_shell_preamble_with_pipefail(body):
+        invocation = _test_invocation_from_prefix(_strip_command_output_plumbing(segment))
+        if invocation is not None:
+            return invocation
+        return None
+    return None
+
+
 def _shell_command_body(command: str) -> str | None:
     """Return the ``-c`` body when the command starts with a shell wrapper."""
     try:
@@ -5808,6 +5911,7 @@ Files present:
             )
 
         unsupported: list[str] = []
+        evidence_form_mismatches: list[str] = []
         backed_commands = tuple(
             command
             for command in _flatten_evidence_values(typed_evidence.get("commands_run"))
@@ -5831,6 +5935,13 @@ Files present:
                 if field_name == "commands_run":
                     if _runtime_messages_support_command_claim(value, field_messages):
                         continue
+                    if _runtime_messages_have_masked_test_command_form(
+                        value,
+                        field_messages,
+                    ):
+                        evidence_form_mismatches.append(f"{field_name}: {value}")
+                        unsupported.append(f"{field_name}: {value}")
+                        continue
                     unsupported.append(f"{field_name}: {value}")
                     continue
                 if field_name == "files_touched":
@@ -5850,16 +5961,35 @@ Files present:
                         task_cwd=self._task_cwd or self._adapter.working_directory,
                     ):
                         continue
+                    if _runtime_messages_have_masked_test_command_for_test_claim(
+                        value=value,
+                        messages=support_messages,
+                        task_cwd=self._task_cwd or self._adapter.working_directory,
+                    ):
+                        evidence_form_mismatches.append(f"{field_name}: {value}")
+                        unsupported.append(f"{field_name}: {value}")
+                        continue
                     unsupported.append(f"{field_name}: {value}")
                     continue
                 if not _runtime_messages_support_claim(value, field_messages):
                     unsupported.append(f"{field_name}: {value}")
 
         if unsupported:
+            failure_class = (
+                "EVIDENCE_FORM_MISMATCH"
+                if evidence_form_mismatches and len(evidence_form_mismatches) == len(unsupported)
+                else "FABRICATION_SUSPECTED"
+            )
+            reason_prefix = (
+                "evidence form mismatch; unprotected output-filter pipeline "
+                "cannot prove a clean command claim"
+                if failure_class == "EVIDENCE_FORM_MISMATCH"
+                else "unsupported evidence claims"
+            )
             return VerifierVerdict(
                 passed=False,
-                reasons=("unsupported evidence claims: " + "; ".join(unsupported),),
-                failure_class="FABRICATION_SUSPECTED",
+                reasons=(reason_prefix + ": " + "; ".join(unsupported),),
+                failure_class=failure_class,
             )
 
         return VerifierVerdict(passed=True)

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/src/ouroboros/orchestrator/verifier.py

@@ -85,6 +85,7 @@ class VerifierContractError(ValueError):
 _VALID_FAILURE_CLASSES: frozenset[str] = frozenset(
     {
         "EVIDENCE_MISSING",
+        "EVIDENCE_FORM_MISMATCH",
         "FABRICATION_SUSPECTED",
         "SCOPE_CREEP",
         "STALL",
@@ -105,8 +106,9 @@ class VerifierVerdict:
             to the executor — a bare FAIL with no reasons is opaque
             and indistinguishable from the first attempt).
         failure_class: Optional hint for H7 (failure taxonomy). One of
-            "EVIDENCE_MISSING", "FABRICATION_SUSPECTED", "SCOPE_CREEP",
-            "STALL", "BLOCKED", or None for an unclassified failure.
+            "EVIDENCE_MISSING", "EVIDENCE_FORM_MISMATCH",
+            "FABRICATION_SUSPECTED", "SCOPE_CREEP", "STALL",
+            "BLOCKED", or None for an unclassified failure.
     """
 
     passed: bool

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/tests/unit/orchestrator/test_failure_taxonomy.py

@@ -133,6 +133,9 @@ class TestPolicyTable:
     def test_evidence_missing_retries(self) -> None:
         assert policy_for(FailureClass.EVIDENCE_MISSING).action == RecoveryAction.RETRY
 
+    def test_evidence_form_mismatch_retries(self) -> None:
+        assert policy_for(FailureClass.EVIDENCE_FORM_MISMATCH).action == RecoveryAction.RETRY
+
     def test_fabrication_escalates_model(self) -> None:
         assert (
             policy_for(FailureClass.FABRICATION_SUSPECTED).action == RecoveryAction.ESCALATE_MODEL

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/tests/unit/orchestrator/test_parallel_executor.py

@@ -33,6 +33,7 @@ from ouroboros.orchestrator.parallel_executor import (
     _criterion_satisfied_by_evidence,
     _effective_evidence_schema_for_ac,
     _message_contains_test_success,
+    _runtime_messages_have_masked_test_command_form,
     _runtime_messages_support_command_claim,
     _runtime_messages_support_test_claim,
     render_parallel_completion_message,
@@ -1164,6 +1165,136 @@ def test_gradle_tests_passed_claim_supports_class_target_and_build_success() ->
     )
 
 
+def test_unprotected_tail_pipe_is_form_mismatch_not_command_proof() -> None:
+    """A bare output-filter pipe is visible but still not trusted as proof."""
+    message = AgentMessage(
+        type="tool",
+        content="Bash command started",
+        tool_name="Bash",
+        data={
+            "tool_input": {
+                "command": (
+                    './gradlew test --tests "com.example.app.unit.SomeNewTest" -i 2>&1 | tail -100'
+                )
+            }
+        },
+    )
+
+    assert not _runtime_messages_support_command_claim(
+        "./gradlew test --tests com.example.app.unit.SomeNewTest -i",
+        (message,),
+    )
+    assert _runtime_messages_have_masked_test_command_form(
+        "./gradlew test --tests com.example.app.unit.SomeNewTest -i",
+        (message,),
+    )
+
+
+def test_atomic_verifier_classifies_masked_test_command_as_form_mismatch() -> None:
+    """Masked test commands are contract mismatches, not fabricated work."""
+    profile = load_profile("code").model_copy(
+        update={"evidence_schema": EvidenceSchema(required=("commands_run",))}
+    )
+    executor = ParallelACExecutor(
+        adapter=MagicMock(working_directory="/workspace"),
+        event_store=AsyncMock(),
+        console=MagicMock(),
+        enable_decomposition=False,
+        execution_profile=profile,
+        fat_harness_mode=True,
+    )
+
+    verdict = executor._verify_atomic_evidence_against_runtime_messages(
+        messages=(
+            AgentMessage(
+                type="tool",
+                content="Bash command started",
+                tool_name="Bash",
+                data={
+                    "tool_input": {
+                        "command": (
+                            './gradlew test --tests "com.example.app.unit.SomeNewTest" '
+                            "-i 2>&1 | tail -100"
+                        )
+                    }
+                },
+            ),
+        ),
+        typed_evidence=EvidenceRecord(
+            data={"commands_run": ["./gradlew test --tests com.example.app.unit.SomeNewTest -i"]}
+        ),
+        ac_content="Run SomeNewTest.",
+    )
+
+    assert verdict.passed is False
+    assert verdict.failure_class == "EVIDENCE_FORM_MISMATCH"
+    assert "unprotected output-filter pipeline" in " ".join(verdict.reasons)
+
+
+def test_atomic_verifier_classifies_dependent_masked_test_evidence_as_form_mismatch(
+    tmp_path,
+) -> None:
+    """Full code evidence with masked test output is one evidence-form mismatch."""
+    source_file = tmp_path / "src" / "app.py"
+    executor = ParallelACExecutor(
+        adapter=MagicMock(working_directory=str(tmp_path)),
+        event_store=AsyncMock(),
+        console=MagicMock(),
+        enable_decomposition=False,
+        execution_profile=load_profile("code"),
+        fat_harness_mode=True,
+    )
+
+    verdict = executor._verify_atomic_evidence_against_runtime_messages(
+        messages=(
+            AgentMessage(
+                type="tool",
+                content="Edit src/app.py",
+                tool_name="Edit",
+                data={"tool_input": {"file_path": str(source_file)}},
+            ),
+            AgentMessage(
+                type="tool",
+                content="Bash command started",
+                tool_name="Bash",
+                data={
+                    "tool_input": {
+                        "command": (
+                            './gradlew test --tests "com.example.app.unit.SomeNewTest" '
+                            "-i 2>&1 | tail -100"
+                        )
+                    }
+                },
+            ),
+            AgentMessage(
+                type="tool_result",
+                content="> Task :test\nBUILD SUCCESSFUL in 8s",
+                tool_name=None,
+                data={
+                    "subtype": "tool_result",
+                    "output": "> Task :test\nBUILD SUCCESSFUL in 8s",
+                },
+            ),
+        ),
+        typed_evidence=EvidenceRecord(
+            data={
+                "files_touched": ["src/app.py"],
+                "commands_run": ["./gradlew test --tests com.example.app.unit.SomeNewTest -i"],
+                "tests_passed": ["com.example.app.unit.SomeNewTest"],
+            }
+        ),
+        ac_content="Update app.py and run SomeNewTest.",
+    )
+
+    assert verdict.passed is False
+    assert verdict.failure_class == "EVIDENCE_FORM_MISMATCH"
+    assert (
+        "commands_run: ./gradlew test --tests com.example.app.unit.SomeNewTest -i"
+        in (verdict.reasons[0])
+    )
+    assert "tests_passed: com.example.app.unit.SomeNewTest" in verdict.reasons[0]
+
+
 @pytest.mark.parametrize(
     ("runtime_command", "claimed_command"),
     (

{ouroboros_ai-0.40.1.dev2 → ouroboros_ai-0.40.2.dev1}/tests/unit/orchestrator/test_verifier.py

@@ -110,6 +110,7 @@ class TestVerifierVerdict:
         "klass",
         [
             "EVIDENCE_MISSING",
+            "EVIDENCE_FORM_MISMATCH",
             "FABRICATION_SUSPECTED",
             "SCOPE_CREEP",
             "STALL",