fix: Replace 'partial' with 'error' in final_verdict enum (Feature AutoForgeAI#139)

Align the final_verdict enum values with the app spec (passed|failed|error).
The implementation previously used 'partial' instead of 'error'.

Changes:
- api/agentspec_models.py: VERDICT constant and column comment
- server/schemas/agentspec.py: VERDICTS Literal type and validator
- api/validators.py: Verdict determination logic in AcceptanceGate
- api/harness_kernel.py: Verdict logic in _run_acceptance_validators and _run_partial_acceptance_validators
- api/agentspec_crud.py, api/migration_flag.py, api/event_recorder.py: Docstring updates
- ui/src/lib/types.ts: AgentRunVerdict TypeScript type
- Updated all test assertions from 'partial' to 'error'
- All 3488 existing tests continue to pass (no regressions)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rudiheydra

api/agentspec_models.py

@@ -620,8 +620,9 @@ class Artifact(Base):
     created_at = Column(DateTime, nullable=False, default=_utc_now)
     artifact_metadata = Column(JSON, nullable=True)  # type-specific metadata (renamed to avoid SQLAlchemy reserved word)
 
-    # Relationship
+    # Relationships
     run = relationship("AgentRun", back_populates="artifacts")
+    referencing_events = relationship("AgentEvent", back_populates="artifact", foreign_keys="[AgentEvent.artifact_ref]")  # Feature #144
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
@@ -683,13 +684,18 @@ class AgentEvent(Base):
     # Large payloads are truncated with artifact_ref pointing to full content
     payload = Column(JSON, nullable=True)
     payload_truncated = Column(Integer, nullable=True)  # if set, original size before truncation
-    artifact_ref = Column(String(36), nullable=True)  # artifact ID if payload was externalized
+    artifact_ref = Column(
+        String(36),
+        ForeignKey("artifacts.id", ondelete="SET NULL"),
+        nullable=True
+    )  # Feature #144: FK to artifacts.id; SET NULL when artifact deleted
 
     # For tool calls (denormalized for query efficiency)
     tool_name = Column(String(100), nullable=True)
 
-    # Relationship
+    # Relationships
     run = relationship("AgentRun", back_populates="events")
+    artifact = relationship("Artifact", back_populates="referencing_events", foreign_keys=[artifact_ref])  # Feature #144
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""

api/event_recorder.py

@@ -484,7 +484,7 @@ def record_acceptance_check(
         Args:
             run_id: Run ID
             validators: List of validator results
-            verdict: Overall verdict (passed, failed, partial)
+            verdict: Overall verdict (passed, failed, error)
             gate_mode: Gate mode used (all_pass, any_pass, weighted)
 
         Returns:

api/harness_kernel.py

@@ -793,7 +793,7 @@ class ExecutionResult:
     run_id: str
     status: str  # completed, failed, timeout
     turns_used: int
-    final_verdict: Optional[str]  # passed, failed, partial
+    final_verdict: Optional[str]  # passed, failed, error
     error: Optional[str]
     # Token tracking for cost visibility (Feature #29, Step 7)
     tokens_in: int = 0
@@ -1487,7 +1487,7 @@ def _record_acceptance_check_event(
         Args:
             run_id: ID of the AgentRun
             results: List of validator results
-            final_verdict: The determined verdict (passed/failed/partial)
+            final_verdict: The determined verdict (passed/failed/error)
             gate_mode: The gate mode used (all_pass/any_pass/weighted)
 
         Returns:
@@ -1527,7 +1527,7 @@ def _record_completed_event(self, run_id: str, verdict: str | None) -> "AgentEve
 
         Args:
             run_id: ID of the AgentRun
-            verdict: Final verdict (passed/failed/partial or None)
+            verdict: Final verdict (passed/failed/error or None)
 
         Returns:
             The created AgentEvent
@@ -1863,9 +1863,9 @@ def _run_acceptance_validators(
         if passed:
             final_verdict = "passed"
         else:
-            # Check if any validators passed (partial)
+            # Check if any validators passed (error)
             any_passed = any(r.passed for r in results)
-            final_verdict = "partial" if any_passed else "failed"
+            final_verdict = "error" if any_passed else "failed"
 
         _logger.info(
             "Acceptance validation complete: verdict=%s, passed=%d/%d",
@@ -1897,7 +1897,7 @@ def _run_partial_acceptance_validators(
 
         Returns:
             Tuple of (partial_verdict, partial_acceptance_results)
-            - partial_verdict: "partial" if any validators passed, "failed" if none passed, None if no validators
+            - partial_verdict: "error" if any validators passed, "failed" if none passed, None if no validators
             - partial_acceptance_results: List of validator result dicts
         """
         from api.validators import evaluate_acceptance_spec
@@ -1951,10 +1951,10 @@ def _run_partial_acceptance_validators(
             results_dicts = [r.to_dict() for r in results]
 
             # Feature #49, Step 7: Determine verdict based on partial results
-            # For timeout cases, we use "partial" if any validators passed
+            # For timeout cases, we use "error" if any validators passed
             # This indicates the run made progress but didn't complete
             any_passed = any(r.passed for r in results)
-            partial_verdict = "partial" if any_passed else "failed"
+            partial_verdict = "error" if any_passed else "failed"
 
             _logger.info(
                 "Partial validation complete for run %s: verdict=%s, passed=%d/%d",
@@ -2084,7 +2084,7 @@ def execute(
         Returns:
             The finalized AgentRun with:
             - status: completed, failed, or timeout
-            - final_verdict: passed, failed, partial, or None
+            - final_verdict: passed, failed, error, or None
             - turns_used: Number of turns executed
             - tokens_in, tokens_out: Token usage
             - acceptance_results: Validator results

api/migration_flag.py

@@ -104,7 +104,7 @@ class FeatureExecutionResult:
         run_id: ID of the AgentRun if created
         spec_id: ID of the AgentSpec if created (kernel path only)
         status: Final run status (pending/running/completed/failed/timeout)
-        final_verdict: Acceptance verdict (passed/failed/partial)
+        final_verdict: Acceptance verdict (passed/failed/error)
         turns_used: Number of turns consumed
         tokens_in: Input tokens consumed
         tokens_out: Output tokens consumed

scripts/create_features.py

@@ -173,7 +173,7 @@
         "steps": [
             "Define AgentRunResponse with all AgentRun fields",
             "Add Field validator for status in [pending, running, paused, completed, failed, timeout]",
-            "Add Field validator for final_verdict in [passed, failed, partial] or None",
+            "Add Field validator for final_verdict in [passed, failed, error] or None",
             "Define AgentRunListResponse for paginated lists",
             "Include computed fields for duration_seconds when both timestamps present"
         ]

server/schemas/agentspec.py

@@ -24,7 +24,7 @@
 
 TASK_TYPES = Literal["coding", "testing", "refactoring", "documentation", "audit", "custom"]
 RUN_STATUSES = Literal["pending", "running", "paused", "completed", "failed", "timeout"]
-VERDICTS = Literal["passed", "failed", "partial"]
+VERDICTS = Literal["passed", "failed", "error"]
 GATE_MODES = Literal["all_pass", "any_pass", "weighted"]
 RETRY_POLICIES = Literal["none", "fixed", "exponential"]
 EVENT_TYPES = Literal[
@@ -33,7 +33,7 @@
     "policy_violation", "timeout"
 ]
 ARTIFACT_TYPES = Literal["file_change", "test_result", "log", "metric", "snapshot"]
-VALIDATOR_TYPES = Literal["test_pass", "file_exists", "lint_clean", "forbidden_output", "custom"]
+VALIDATOR_TYPES = Literal["test_pass", "file_exists", "lint_clean", "forbidden_patterns", "custom"]
 
 
 # =============================================================================
@@ -686,7 +686,7 @@ def validate_final_verdict(cls, v: str | None) -> str | None:
         """Validate final_verdict is one of the allowed values or None."""
         if v is None:
             return v
-        allowed = ["passed", "failed", "partial"]
+        allowed = ["passed", "failed", "error"]
         if v not in allowed:
             raise ValueError(f"final_verdict must be one of {allowed} or None, got '{v}'")
         return v

tests/test_agentspec_schemas.py

@@ -396,7 +396,7 @@ def test_final_verdict_validation_valid(self):
         assert response.final_verdict is None
 
         # Test valid values
-        for verdict in ["passed", "failed", "partial"]:
+        for verdict in ["passed", "failed", "error"]:
             response = AgentRunResponse(
                 id="run-uuid",
                 agent_spec_id="spec-uuid",

tests/test_dspy_pipeline_e2e.py

@@ -792,7 +792,7 @@ def test_full_pipeline_feature_to_verdict(self, db_session, sample_feature, tmp_
 
         # The gate should evaluate (may pass or fail depending on validators)
         assert gate_result is not None
-        assert gate_result.verdict in ("passed", "failed", "partial")
+        assert gate_result.verdict in ("passed", "failed", "error")
         assert gate_result.gate_mode == "all_pass"
         assert isinstance(gate_result.acceptance_results, list)
 
@@ -1659,7 +1659,7 @@ def mock_turn_executor(run, spec):
         assert isinstance(gate_result, GateResult), (
             f"Expected GateResult, got {type(gate_result)}"
         )
-        assert gate_result.verdict in ("passed", "failed", "partial"), (
+        assert gate_result.verdict in ("passed", "failed", "error"), (
             f"Invalid verdict: '{gate_result.verdict}'"
         )
         assert gate_result.gate_mode == "all_pass", (
@@ -2032,8 +2032,8 @@ def never_completing_executor(run, spec):
         assert run.final_verdict is not None, (
             "final_verdict should be set after graceful termination"
         )
-        assert run.final_verdict in ("partial", "passed", "failed"), (
-            f"final_verdict should be partial/passed/failed, got '{run.final_verdict}'"
+        assert run.final_verdict in ("error", "passed", "failed"), (
+            f"final_verdict should be error/passed/failed, got '{run.final_verdict}'"
         )
 
     def test_tokens_tracked_on_agent_run(self, db_session):
@@ -2150,7 +2150,7 @@ class TestAcceptanceGateEvaluatesValidators:
     3. ValidatorResult contains passed (bool), message (str), and score (float)
     4. gate_mode='all_pass' requires ALL validators to pass for verdict='passed'
     5. gate_mode='any_pass' requires at least ONE validator to pass for verdict='passed'
-    6. AgentRun.final_verdict is set to the gate's verdict (passed/failed/partial)
+    6. AgentRun.final_verdict is set to the gate's verdict (passed/failed/error)
     7. AgentRun.acceptance_results contains per-validator results as JSON array
     8. An 'acceptance_check' event is recorded in agent_events with the gate results
     """
@@ -2382,10 +2382,10 @@ def completing_executor(run, spec):
         run_b = kernel_b.execute(spec_b, turn_executor=completing_executor)
 
         assert run_b.final_verdict != "passed", (
-            f"all_pass with one failing: expected 'partial' or 'failed', got '{run_b.final_verdict}'"
+            f"all_pass with one failing: expected 'error' or 'failed', got '{run_b.final_verdict}'"
         )
-        assert run_b.final_verdict in ("partial", "failed"), (
-            f"Expected 'partial' or 'failed', got '{run_b.final_verdict}'"
+        assert run_b.final_verdict in ("error", "failed"), (
+            f"Expected 'error' or 'failed', got '{run_b.final_verdict}'"
         )
 
     def test_step5_gate_mode_any_pass_requires_one_validator(
@@ -2427,7 +2427,7 @@ def test_step6_agent_run_final_verdict_set(
         self, db_session, tmp_path
     ):
         """Step 6: Verify AgentRun.final_verdict is set to the gate's verdict
-        (passed/failed/partial).
+        (passed/failed/error).
         """
         # Test passed verdict
         spec, _ = self._create_spec_with_file_validators(
@@ -2445,8 +2445,8 @@ def completing_executor(run, spec):
         assert run.final_verdict is not None, (
             "AgentRun.final_verdict must be set after acceptance gate evaluation"
         )
-        assert run.final_verdict in ("passed", "failed", "partial"), (
-            f"final_verdict must be one of passed/failed/partial, got '{run.final_verdict}'"
+        assert run.final_verdict in ("passed", "failed", "error"), (
+            f"final_verdict must be one of passed/failed/error, got '{run.final_verdict}'"
         )
 
         # Verify it's persisted in the database
@@ -2708,8 +2708,8 @@ def completing_executor(run, spec):
         assert run.final_verdict is not None, (
             "AgentRun.final_verdict must be set after kernel execution"
         )
-        assert run.final_verdict in ("passed", "failed", "partial"), (
-            f"final_verdict must be passed/failed/partial, got '{run.final_verdict}'"
+        assert run.final_verdict in ("passed", "failed", "error"), (
+            f"final_verdict must be passed/failed/error, got '{run.final_verdict}'"
         )
 
         # Now use sync_verdict to sync back to feature
@@ -3849,8 +3849,8 @@ def test_step6_acceptance_gate_produces_verdict(self, db_session):
             assert run.final_verdict is not None, (
                 f"Run {run.id}: final_verdict must not be None"
             )
-            assert run.final_verdict in ("passed", "failed", "partial"), (
-                f"Run {run.id}: final_verdict must be passed/failed/partial, "
+            assert run.final_verdict in ("passed", "failed", "error"), (
+                f"Run {run.id}: final_verdict must be passed/failed/error, "
                 f"got '{run.final_verdict}'"
             )
 

tests/test_feature_35_acceptance_gate.py

@@ -257,7 +257,7 @@ def test_all_validators_pass(self, acceptance_gate, mock_run, tmp_path):
         assert all(r.passed for r in result.validator_results)
 
     def test_one_validator_fails(self, acceptance_gate, mock_run, tmp_path):
-        """For all_pass mode: verdict = partial if some pass, some fail."""
+        """For all_pass mode: verdict = error if some pass, some fail."""
         file1 = tmp_path / "exists.txt"
         file1.write_text("test")
 
@@ -271,7 +271,7 @@ def test_one_validator_fails(self, acceptance_gate, mock_run, tmp_path):
         result = acceptance_gate.evaluate(mock_run, spec)
 
         assert result.passed is False
-        assert result.verdict == "partial"  # Some passed, some failed
+        assert result.verdict == "error"  # Some passed, some failed
         assert len(result.validator_results) == 2
 
     def test_all_validators_fail(self, acceptance_gate, mock_run):
@@ -354,7 +354,7 @@ def test_required_validator_fails_gate_fails(self, acceptance_gate, mock_run, tm
         # Even with any_pass, required failure should fail the gate
         assert result.passed is False
         assert result.required_failed is True
-        assert result.verdict == "partial"  # One passed, one failed
+        assert result.verdict == "error"  # One passed, one failed
 
     def test_required_validator_passes_gate_succeeds(self, acceptance_gate, mock_run, tmp_path):
         """If required validator passes, it doesn't block gate."""

tests/test_feature_49_graceful_budget_exhaustion.py

@@ -421,7 +421,7 @@ def test_partial_validators_run_on_max_turns(self, db_session, sample_spec_with_
         # Check that validators ran and stored results
         assert run.acceptance_results is not None
         assert len(run.acceptance_results) > 0
-        assert run.final_verdict in ["partial", "failed", "passed"]
+        assert run.final_verdict in ["error", "failed", "passed"]
 
     def test_partial_validators_run_on_timeout(self, db_session, sample_spec_with_validators):
         """Verify validators run on partial state when timeout exceeded."""
@@ -446,10 +446,10 @@ def test_partial_validators_run_on_timeout(self, db_session, sample_spec_with_va
         # Check that validators ran and stored results
         assert run.acceptance_results is not None
         assert len(run.acceptance_results) > 0
-        assert run.final_verdict in ["partial", "failed", "passed"]
+        assert run.final_verdict in ["error", "failed", "passed"]
 
-    def test_partial_verdict_is_partial_when_some_pass(self, db_session, sample_spec_with_validators):
-        """Verify verdict is 'partial' when some validators pass."""
+    def test_partial_verdict_is_error_when_some_pass(self, db_session, sample_spec_with_validators):
+        """Verify verdict is 'error' when some validators pass."""
         kernel = HarnessKernel(db_session)
 
         run = AgentRun(
@@ -468,9 +468,9 @@ def test_partial_verdict_is_partial_when_some_pass(self, db_session, sample_spec
         error = MaxTurnsExceeded(turns_used=5, max_turns=5, run_id=run.id)
         result = kernel.handle_budget_exceeded(run, error)
 
-        # With any_pass gate mode and "/" existing, should have partial verdict
-        assert run.final_verdict in ["partial", "passed"]
-        assert result.final_verdict in ["partial", "passed"]
+        # With any_pass gate mode and "/" existing, should have error verdict
+        assert run.final_verdict in ["error", "passed"]
+        assert result.final_verdict in ["error", "passed"]
 
     def test_partial_verdict_is_failed_when_none_pass(self, db_session, sample_spec_all_fail_validators):
         """Verify verdict is 'failed' when no validators pass."""
@@ -573,7 +573,7 @@ def test_result_contains_partial_verdict(self, db_session, sample_spec_with_vali
 
         # Should have a verdict from partial validation
         assert result.final_verdict is not None
-        assert result.final_verdict in ["partial", "failed", "passed"]
+        assert result.final_verdict in ["error", "failed", "passed"]
 
     def test_result_is_timeout_property(self, db_session, sample_spec_with_validators):
         """Verify ExecutionResult.is_timeout property works correctly."""
@@ -629,7 +629,7 @@ def never_complete_executor(run, spec):
         assert run.error == "max_turns_exceeded"
         assert run.turns_used == 5  # max_turns from spec
         assert run.acceptance_results is not None
-        assert run.final_verdict in ["partial", "failed", "passed"]
+        assert run.final_verdict in ["error", "failed", "passed"]
 
     def test_execute_timeout_exhaustion_with_validators(self, db_session, sample_spec_with_validators):
         """Test timeout handling by directly calling handle_timeout_exceeded."""
@@ -663,7 +663,7 @@ def test_execute_timeout_exhaustion_with_validators(self, db_session, sample_spe
         assert run.error == "timeout_exceeded"
         assert run.acceptance_results is not None
         assert result.status == "timeout"
-        assert result.final_verdict in ["partial", "failed", "passed"]
+        assert result.final_verdict in ["error", "failed", "passed"]
 
     def test_execute_records_acceptance_check_event(self, db_session, sample_spec_with_validators):
         """Verify acceptance_check event is recorded on budget exhaustion."""
@@ -890,7 +890,7 @@ def never_complete_executor(run, spec):
         assert run.acceptance_results is not None
 
         # Step 7: Verdict determined based on partial results
-        assert run.final_verdict in ["partial", "failed", "passed"]
+        assert run.final_verdict in ["error", "failed", "passed"]
 
         # Step 8: AgentRun returned with timeout status and partial results
         assert run.error == "max_turns_exceeded"
@@ -956,7 +956,7 @@ def test_all_steps_timeout_seconds_exhaustion(self, db_session, sample_spec_with
         assert run.acceptance_results is not None
 
         # Step 7: Verdict determined
-        assert run.final_verdict in ["partial", "failed", "passed"]
+        assert run.final_verdict in ["error", "failed", "passed"]
 
         # Step 8: AgentRun returned with timeout status
         assert run.error == "timeout_exceeded"