loopx 0.4.8__py3-none-any.whl

loopx/control_plane/goals/goal_frontier/replan_rules.py

@@ -0,0 +1,210 @@
+"""Goal-frontier replan rule selection: the decision interpreter for the
+`goal_frontier` bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+GOAL_FRONTIER_REPLAN_RULE_DECISION_SCHEMA_VERSION = (
+    "goal_frontier_replan_rule_decision_v0"
+)
+
+
+class GoalFrontierReplanRule(str, Enum):
+    EXISTING_OBLIGATION = "existing_obligation"
+    BLOCKING_HANDOFF_GATE = "blocking_handoff_gate"
+    READY_DEFERRED_SUCCESSOR = "ready_deferred_successor"
+    OPEN_USER_TODO = "open_user_todo"
+    USER_ACTION_OWNS_EMPTY_FRONTIER = "user_action_owns_empty_frontier"
+    TODO_SUCCESSION_GAP = "todo_succession_gap"
+    VISION_ACCEPTANCE_GAP = "vision_acceptance_gap"
+    LONG_TODO_CHAIN = "long_todo_chain"
+    CURRENT_AGENT_BLOCKER = "current_agent_blocker"
+    MONITOR_NO_CHANGE_STREAK = "monitor_no_change_streak"
+    NOT_MONITOR_ONLY = "not_monitor_only"
+    NO_OPEN_MONITOR = "no_open_monitor"
+    ADVANCEMENT_REMAINS = "advancement_remains"
+    DUE_MONITOR_EXECUTION = "due_monitor_execution"
+    FUTURE_MONITOR_WAIT = "future_monitor_wait"
+    MONITOR_FRONTIER_EXHAUSTED = "monitor_frontier_exhausted"
+
+
+GOAL_FRONTIER_REPLAN_RULE_ORDER = tuple(GoalFrontierReplanRule)
+
+
+@dataclass(frozen=True)
+class GoalFrontierReplanFacts:
+    existing_replan_required: bool = False
+    blocking_handoff_gate_count: int = 0
+    ready_deferred_successor_count: int = 0
+    successor_vision_required: bool = False
+    blocking_user_open_count: int = 0
+    user_open_count: int = 0
+    succession_gap_count: int = 0
+    succession_gap_acknowledged: bool = False
+    vision_gap_acknowledged: bool = False
+    agent_advancement_count: int = 0
+    total_frontier_advancement: int = 0
+    acceptance_gap_count: int = 0
+    selectable_frontier_advancement: int = 0
+    outcome_checkpoint_replan_required: bool = False
+    long_todo_chain_triggered: bool = False
+    current_agent_blocker_count: int = 0
+    monitor_no_change_streak_triggered: bool = False
+    monitor_only_lane: bool = False
+    monitor_count: int = 0
+    monitor_due_count: int = 0
+    monitor_schedule_gap_count: int = 0
+    future_monitor_schedule_present: bool = False
+    monitor_lane_semantically_valid: bool = True
+
+
+@dataclass(frozen=True)
+class GoalFrontierReplanRuleDecision:
+    rule: GoalFrontierReplanRule
+    derives_obligation: bool
+    reason: str
+
+    def to_payload(self) -> dict[str, object]:
+        return {
+            "schema_version": GOAL_FRONTIER_REPLAN_RULE_DECISION_SCHEMA_VERSION,
+            "rule": self.rule.value,
+            "rule_index": GOAL_FRONTIER_REPLAN_RULE_ORDER.index(self.rule),
+            "derives_obligation": self.derives_obligation,
+            "reason": self.reason,
+        }
+
+
+def select_goal_frontier_replan_rule(
+    facts: GoalFrontierReplanFacts,
+) -> GoalFrontierReplanRuleDecision:
+    """Select the first matching goal-frontier rule in policy order."""
+
+    ordered_rules = (
+        (
+            GoalFrontierReplanRule.EXISTING_OBLIGATION,
+            facts.existing_replan_required,
+            False,
+            "an existing scoped obligation remains authoritative",
+        ),
+        (
+            GoalFrontierReplanRule.BLOCKING_HANDOFF_GATE,
+            facts.blocking_handoff_gate_count > 0,
+            False,
+            "a blocking handoff gate owns the next transition",
+        ),
+        (
+            GoalFrontierReplanRule.READY_DEFERRED_SUCCESSOR,
+            facts.ready_deferred_successor_count > 0
+            and not facts.successor_vision_required,
+            False,
+            "a deferred successor is already runnable",
+        ),
+        (
+            GoalFrontierReplanRule.OPEN_USER_TODO,
+            facts.blocking_user_open_count > 0,
+            False,
+            "open blocking user work owns the frontier",
+        ),
+        (
+            GoalFrontierReplanRule.TODO_SUCCESSION_GAP,
+            facts.succession_gap_count > 0
+            and facts.agent_advancement_count == 0
+            and facts.total_frontier_advancement == 0
+            and not facts.succession_gap_acknowledged,
+            True,
+            "completed advancement work lacks a successor or no-followup rationale",
+        ),
+        (
+            GoalFrontierReplanRule.VISION_ACCEPTANCE_GAP,
+            facts.acceptance_gap_count > 0
+            and not facts.vision_gap_acknowledged
+            and (
+                facts.successor_vision_required
+                or facts.outcome_checkpoint_replan_required
+                or facts.selectable_frontier_advancement == 0
+            ),
+            True,
+            (
+                "the scoped vision gap lacks a fresh evidence-linked outcome "
+                "checkpoint or satisfying runnable frontier"
+            ),
+        ),
+        (
+            GoalFrontierReplanRule.LONG_TODO_CHAIN,
+            facts.long_todo_chain_triggered,
+            True,
+            "the selectable todo chain crossed the bounded replan threshold",
+        ),
+        (
+            GoalFrontierReplanRule.CURRENT_AGENT_BLOCKER,
+            facts.current_agent_blocker_count > 0,
+            False,
+            "an explicit current-agent blocker owns the empty frontier",
+        ),
+        (
+            GoalFrontierReplanRule.MONITOR_NO_CHANGE_STREAK,
+            facts.monitor_only_lane
+            and facts.monitor_count > 0
+            and facts.monitor_no_change_streak_triggered,
+            True,
+            "the current agent monitor crossed the no-change replan threshold",
+        ),
+        (
+            GoalFrontierReplanRule.USER_ACTION_OWNS_EMPTY_FRONTIER,
+            facts.user_open_count > 0 and facts.total_frontier_advancement == 0,
+            False,
+            "open user-owned work owns the empty frontier",
+        ),
+        (
+            GoalFrontierReplanRule.NOT_MONITOR_ONLY,
+            not facts.monitor_only_lane,
+            False,
+            "the selected lane is not monitor-only",
+        ),
+        (
+            GoalFrontierReplanRule.NO_OPEN_MONITOR,
+            facts.monitor_count <= 0,
+            False,
+            "no open monitor remains",
+        ),
+        (
+            GoalFrontierReplanRule.ADVANCEMENT_REMAINS,
+            facts.agent_advancement_count > 0
+            or facts.total_frontier_advancement > 0,
+            False,
+            "advancement work remains on the frontier",
+        ),
+        (
+            GoalFrontierReplanRule.DUE_MONITOR_EXECUTION,
+            facts.monitor_due_count > 0
+            and facts.monitor_schedule_gap_count == 0
+            and facts.monitor_lane_semantically_valid,
+            False,
+            "a scheduled monitor is due and remains executable",
+        ),
+        (
+            GoalFrontierReplanRule.FUTURE_MONITOR_WAIT,
+            facts.future_monitor_schedule_present
+            and facts.monitor_due_count == 0
+            and facts.monitor_schedule_gap_count == 0
+            and facts.monitor_lane_semantically_valid,
+            False,
+            "the monitor-only lane has a valid future schedule and should wait quietly",
+        ),
+        (
+            GoalFrontierReplanRule.MONITOR_FRONTIER_EXHAUSTED,
+            True,
+            True,
+            "only monitor work remains on an empty advancement frontier",
+        ),
+    )
+    for rule, matches, derives_obligation, reason in ordered_rules:
+        if matches:
+            return GoalFrontierReplanRuleDecision(
+                rule=rule,
+                derives_obligation=derives_obligation,
+                reason=reason,
+            )
+    raise AssertionError("goal-frontier replan rules must have a terminal rule")

loopx/control_plane/goals/goal_frontier/semantic_history.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ...work_items.autonomous_replan_ack import (
+    latest_autonomous_replan_ack_for_projection,
+)
+
+VISION_CHECKPOINT_SATISFIED_DECISIONS = {
+    "patched",
+    "unchanged_with_reason",
+}
+
+
+def _run_history_goal(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+) -> dict[str, Any] | None:
+    run_history = (
+        status_payload.get("run_history")
+        if isinstance(status_payload.get("run_history"), dict)
+        else {}
+    )
+    goals = (
+        run_history.get("goals") if isinstance(run_history.get("goals"), list) else []
+    )
+    return next(
+        (
+            item
+            for item in goals
+            if isinstance(item, dict) and str(item.get("id") or "") == goal_id
+        ),
+        None,
+    )
+
+
+def _latest_runs_for_goal(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+) -> list[dict[str, Any]]:
+    goal = _run_history_goal(status_payload, goal_id=goal_id)
+    latest_runs = goal.get("latest_runs") if isinstance(goal, dict) else None
+    return (
+        [item for item in latest_runs if isinstance(item, dict)]
+        if isinstance(latest_runs, list)
+        else []
+    )
+
+
+def latest_runs_for_goal(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+) -> list[dict[str, Any]]:
+    """Return newest-first compact runs used by semantic reducers."""
+
+    return _latest_runs_for_goal(status_payload, goal_id=goal_id)
+
+
+def _semantic_agent_context_for_goal(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+) -> tuple[bool, dict[str, Any] | None]:
+    """Return whether semantic history is authoritative and its agent lane."""
+
+    if not agent_id:
+        return False, None
+    goal = _run_history_goal(status_payload, goal_id=goal_id)
+    semantic_history = goal.get("semantic_history") if isinstance(goal, dict) else None
+    if not isinstance(semantic_history, dict):
+        return False, None
+    contexts = semantic_history.get("agents")
+    if not isinstance(contexts, list):
+        return True, None
+    return True, next(
+        (
+            context
+            for context in contexts
+            if isinstance(context, dict)
+            and str(context.get("agent_id") or "").strip() == agent_id
+        ),
+        None,
+    )
+
+
+def _run_agent_id_matches(run: dict[str, Any], *, agent_id: str | None) -> bool:
+    if not agent_id:
+        return True
+    run_agent_id = str(run.get("agent_id") or "").strip()
+    return not run_agent_id or run_agent_id == agent_id
+
+
+def latest_agent_vision_from_status_payload(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+) -> dict[str, Any] | None:
+    """Return the newest compact agent vision packet visible in run history."""
+
+    semantic_history_present, context = _semantic_agent_context_for_goal(
+        status_payload,
+        goal_id=goal_id,
+        agent_id=agent_id,
+    )
+    if semantic_history_present:
+        if not isinstance(context, dict) or context.get("vision_retired_at"):
+            return None
+        vision_run = context.get("latest_agent_vision_run")
+        return (
+            latest_agent_vision_from_runs(
+                [vision_run],
+                goal_id=goal_id,
+                agent_id=agent_id,
+            )
+            if isinstance(vision_run, dict)
+            else None
+        )
+    return latest_agent_vision_from_runs(
+        _latest_runs_for_goal(status_payload, goal_id=goal_id),
+        goal_id=goal_id,
+        agent_id=agent_id,
+    )
+
+
+def latest_agent_vision_from_runs(
+    runs: list[dict[str, Any]],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+) -> dict[str, Any] | None:
+    """Return the newest active vision from newest-first compact run records."""
+
+    for run in runs:
+        vision = run.get("agent_vision")
+        if not isinstance(vision, dict):
+            continue
+        vision_agent_id = str(
+            vision.get("agent_id") or run.get("agent_id") or ""
+        ).strip()
+        if agent_id and vision_agent_id and vision_agent_id != agent_id:
+            continue
+        patch = (
+            vision.get("vision_patch")
+            if isinstance(vision.get("vision_patch"), dict)
+            else {}
+        )
+        if not patch:
+            continue
+        result = {
+            "schema_version": vision.get("schema_version"),
+            "goal_id": goal_id,
+            "agent_id": vision_agent_id or agent_id,
+            "state": vision.get("state"),
+            "vision_patch": patch,
+            "todo_delta": vision.get("todo_delta")
+            if isinstance(vision.get("todo_delta"), list)
+            else [],
+            "vision_budget": vision.get("vision_budget")
+            if isinstance(vision.get("vision_budget"), dict)
+            else None,
+            "generated_at": run.get("generated_at"),
+        }
+        if isinstance(vision.get("path_delta"), dict):
+            result["path_delta"] = vision["path_delta"]
+        return result
+    return None
+
+
+def _latest_missing_vision_checkpoint_from_runs(
+    runs: list[dict[str, Any]],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+) -> dict[str, Any] | None:
+    for run in runs:
+        checkpoint = run.get("vision_checkpoint")
+        if not isinstance(checkpoint, dict):
+            continue
+        checkpoint_agent_id = str(
+            checkpoint.get("agent_id") or run.get("agent_id") or ""
+        ).strip()
+        if agent_id and checkpoint_agent_id != agent_id:
+            continue
+        if not agent_id and checkpoint_agent_id:
+            continue
+        decision = str(checkpoint.get("decision") or "").strip()
+        if (
+            checkpoint.get("satisfied") is True
+            and decision in VISION_CHECKPOINT_SATISFIED_DECISIONS
+        ):
+            return None
+        if checkpoint.get("required") is not True:
+            continue
+        if checkpoint.get("satisfied") is not False:
+            continue
+        if decision != "missing_required":
+            continue
+        return {
+            "schema_version": checkpoint.get("schema_version"),
+            "goal_id": goal_id,
+            "agent_id": checkpoint_agent_id or agent_id,
+            "decision": checkpoint.get("decision"),
+            "triggers": checkpoint.get("triggers")
+            if isinstance(checkpoint.get("triggers"), list)
+            else [],
+            "required_resolution": checkpoint.get("required_resolution")
+            if isinstance(checkpoint.get("required_resolution"), list)
+            else [],
+            "missing_baseline": checkpoint.get("missing_baseline") is True,
+            "generated_at": run.get("generated_at"),
+        }
+    return None
+
+
+def latest_missing_vision_checkpoint_from_status_payload(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+) -> dict[str, Any] | None:
+    """Return the newest unsatisfied per-agent vision checkpoint in run history."""
+
+    semantic_history_present, context = _semantic_agent_context_for_goal(
+        status_payload,
+        goal_id=goal_id,
+        agent_id=agent_id,
+    )
+    if semantic_history_present:
+        checkpoint_run = (
+            context.get("latest_vision_checkpoint_run")
+            if isinstance(context, dict)
+            else None
+        )
+        return _latest_missing_vision_checkpoint_from_runs(
+            [checkpoint_run] if isinstance(checkpoint_run, dict) else [],
+            goal_id=goal_id,
+            agent_id=agent_id,
+        )
+    return _latest_missing_vision_checkpoint_from_runs(
+        _latest_runs_for_goal(status_payload, goal_id=goal_id),
+        goal_id=goal_id,
+        agent_id=agent_id,
+    )
+
+
+def latest_autonomous_replan_ack_from_status_payload(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+    neutral_classifications: set[str],
+) -> dict[str, Any] | None:
+    """Return the newest agent-scoped durable replan ACK visible in run history."""
+
+    if not agent_id:
+        return None
+    semantic_history_present, context = _semantic_agent_context_for_goal(
+        status_payload,
+        goal_id=goal_id,
+        agent_id=agent_id,
+    )
+    if semantic_history_present:
+        ack_run = (
+            context.get("latest_autonomous_replan_ack_run")
+            if isinstance(context, dict)
+            else None
+        )
+        latest_runs = [ack_run] if isinstance(ack_run, dict) else []
+    else:
+        latest_runs = [
+            run
+            for run in _latest_runs_for_goal(status_payload, goal_id=goal_id)
+            if _run_agent_id_matches(run, agent_id=agent_id)
+        ]
+    return latest_autonomous_replan_ack_for_projection(
+        latest_runs,
+        neutral_classifications=neutral_classifications,
+    )
+
+
+def latest_replan_ack_feedback_from_status_payload(
+    status_payload: dict[str, Any],
+    *,
+    goal_id: str,
+    agent_id: str | None,
+) -> dict[str, Any] | None:
+    """Return the newest rejected replan ACK reason for one agent lane."""
+
+    semantic_history_present, context = _semantic_agent_context_for_goal(
+        status_payload,
+        goal_id=goal_id,
+        agent_id=agent_id,
+    )
+    if semantic_history_present:
+        run = (
+            context.get("latest_replan_ack_feedback_run")
+            if isinstance(context, dict)
+            else None
+        )
+        candidates = [run] if isinstance(run, dict) else []
+    else:
+        candidates = _latest_runs_for_goal(status_payload, goal_id=goal_id)
+    for run in candidates:
+        if not _run_agent_id_matches(run, agent_id=agent_id):
+            continue
+        feedback = run.get("replan_ack_feedback")
+        if isinstance(feedback, dict):
+            return feedback
+    return None

loopx/control_plane/goals/goal_frontier/terminal.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from typing import Any
+
+GOAL_TERMINAL_STATE_SCHEMA_VERSION = "goal_terminal_state_v0"
+GOAL_TERMINAL_SOURCE_COMPLETENESS_SCHEMA_VERSION = "goal_terminal_source_completeness_v0"
+VISION_CHECKPOINT_NO_FOLLOWUP_RESOLUTION = "record_no_followup"
+
+def _strict_zero(value: Any) -> bool:
+    return type(value) is int and value == 0
+
+
+def _terminal_todo_source_state(
+    summary: dict[str, Any] | None,
+    *,
+    role: str,
+) -> tuple[str, bool]:
+    if not isinstance(summary, dict):
+        return "missing", False
+    completeness = summary.get("source_completeness")
+    if not (
+        isinstance(completeness, dict)
+        and completeness.get("schema_version") == "todo_source_completeness_v0"
+        and completeness.get("status") == "valid"
+        and completeness.get("source") == "structured_todo_projection"
+        and completeness.get("role") == role
+        and completeness.get("terminal_closure") == "valid"
+    ):
+        return "invalid", False
+    total = summary.get("total_count")
+    done = summary.get("done_count")
+    deferred = summary.get("deferred_count")
+    watch_only = summary.get("watch_only_monitor_count", 0)
+    if not (
+        type(total) is int
+        and total >= 0
+        and type(done) is int
+        and type(watch_only) is int
+        and watch_only >= 0
+        and done + watch_only == total
+        and _strict_zero(summary.get("convergence_open_count", summary.get("open_count")))
+        and _strict_zero(deferred)
+        and isinstance(summary.get("monitor_open_items"), list)
+        and len(summary.get("monitor_open_items")) == watch_only
+    ):
+        return "invalid", False
+    intent = summary.get("closure_intent")
+    has_no_followup_intent = bool(
+        isinstance(intent, dict)
+        and intent.get("schema_version") == "todo_closure_intent_v0"
+        and intent.get("kind") == "no_followup"
+        and intent.get("derived") is True
+        and intent.get("source") == "todo_no_followup"
+        and type(intent.get("count")) is int
+        and 0 < intent.get("count") <= done
+    )
+    return "valid", has_no_followup_intent
+
+
+def _projection_has_empty_terminal_frontier(projection: dict[str, Any] | None) -> bool:
+    if not isinstance(projection, dict):
+        return False
+
+    normalized = projection.get("normalized_progress")
+    frontier = projection.get("remaining_advancement_frontier")
+    monitors = projection.get("monitor_only_lanes")
+    successors = projection.get("deferred_successors")
+    if not all(isinstance(value, dict) for value in (normalized, frontier, monitors, successors)):
+        return False
+
+    required_keys = (
+        (normalized, {"user_open_count", "agent_open_count", "agent_advancement_open_count", "agent_monitor_open_count", "agent_monitor_due_count"}),
+        (frontier, {"current_agent_claimed_advancement_count", "unclaimed_advancement_count", "other_agent_claimed_advancement_count"}),
+        (monitors, {"present", "quiet_until_material_transition"}),
+        (successors, {"ready_count", "blocked_count", "current_agent_ready_count"}),
+    )
+    if any(not keys.issubset(values) for values, keys in required_keys):
+        return False
+
+    projected_counts = (
+        normalized.get("user_open_count"),
+        normalized.get("agent_open_count"),
+        normalized.get("agent_advancement_open_count"),
+        normalized.get("agent_monitor_open_count"),
+        normalized.get("agent_monitor_due_count"),
+        frontier.get("current_agent_claimed_advancement_count"),
+        frontier.get("unclaimed_advancement_count"),
+        frontier.get("other_agent_claimed_advancement_count"),
+        successors.get("ready_count"),
+        successors.get("blocked_count"),
+        successors.get("current_agent_ready_count"),
+    )
+    return (
+        all(_strict_zero(value) for value in projected_counts)
+        and monitors.get("present") is False
+        and monitors.get("quiet_until_material_transition") is False
+        and projection.get("acceptance_gaps") == []
+        and projection.get("autonomy_blockers") == []
+        and projection.get("replan_required") is False
+    )
+
+
+def _terminal_todo_source_contract(
+    *,
+    user_todo_summary: dict[str, Any] | None,
+    agent_todo_summary: dict[str, Any] | None,
+) -> tuple[dict[str, Any], bool]:
+    user_status, user_intent = _terminal_todo_source_state(user_todo_summary, role="user")
+    agent_status, agent_intent = _terminal_todo_source_state(agent_todo_summary, role="agent")
+    source_completeness = {
+        "schema_version": GOAL_TERMINAL_SOURCE_COMPLETENESS_SCHEMA_VERSION,
+        "user_todos": user_status,
+        "agent_todos": agent_status,
+    }
+    return (
+        source_completeness,
+        user_status == agent_status == "valid" and (user_intent or agent_intent),
+    )
+
+
+def derive_goal_terminal_state(
+    *,
+    user_todo_summary: dict[str, Any] | None,
+    agent_todo_summary: dict[str, Any] | None,
+    projection: dict[str, Any],
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    source_completeness, source_closure_confirmed = _terminal_todo_source_contract(
+        user_todo_summary=user_todo_summary,
+        agent_todo_summary=agent_todo_summary,
+    )
+    if not (
+        source_closure_confirmed
+        and _projection_has_empty_terminal_frontier(projection)
+    ):
+        return source_completeness, None
+    return source_completeness, {
+        "schema_version": GOAL_TERMINAL_STATE_SCHEMA_VERSION,
+        "kind": "no_followup",
+        "derived": True,
+        "source": "validated_goal_closure",
+    }
+
+
+def _terminal_no_followup_resolves_vision_checkpoint(
+    *,
+    user_todo_summary: dict[str, Any] | None,
+    agent_todo_summary: dict[str, Any] | None,
+    checkpoint: dict[str, Any] | None,
+) -> bool:
+    if not isinstance(checkpoint, dict):
+        return False
+    required_resolution = checkpoint.get("required_resolution")
+    if not (
+        isinstance(required_resolution, list)
+        and VISION_CHECKPOINT_NO_FOLLOWUP_RESOLUTION in required_resolution
+    ):
+        return False
+    _, source_closure_confirmed = _terminal_todo_source_contract(
+        user_todo_summary=user_todo_summary,
+        agent_todo_summary=agent_todo_summary,
+    )
+    return source_closure_confirmed
+
+
+def goal_frontier_is_terminal_no_followup(*, projection: dict[str, Any] | None) -> bool:
+    if not _projection_has_empty_terminal_frontier(projection):
+        return False
+    terminal_state = projection.get("terminal_state")
+    completeness = projection.get("source_completeness")
+    return bool(
+        isinstance(terminal_state, dict)
+        and terminal_state.get("schema_version") == GOAL_TERMINAL_STATE_SCHEMA_VERSION
+        and terminal_state.get("kind") == "no_followup"
+        and terminal_state.get("derived") is True
+        and terminal_state.get("source") == "validated_goal_closure"
+        and isinstance(completeness, dict)
+        and completeness.get("schema_version") == GOAL_TERMINAL_SOURCE_COMPLETENESS_SCHEMA_VERSION
+        and completeness.get("user_todos") == "valid"
+        and completeness.get("agent_todos") == "valid"
+    )