Iteration 4: - Overlay Skills (step 12): an Execution names an organisation's standards Skill from the folders the deployment configures; recorded with its version. An example standards Skill and an evaluation case that uses it. - Lessons (step 10): a prove command that compares a run with lessons against one without, and triage of evidence an existing lesson already covers. Iteration 5: - Step 8: the references of a Specialist's Skills its task needs are named in its context as read_first. - Step 14: a remote MCP server's reply that instructs the agent is withheld; the user's own text is flagged as a risk and nothing more. - Step 15: in a Change request, items only reworded are listed apart from real changes. - Step 19: each Execution's design recommendations are judged when it ends and the scores kept in its record. The evaluation takes its rubric from the same place. Each question was calibrated against live Jev; none has run in a case. Steps 6, 7, 9, 13 and 18 stay planned, with the reasons in the plan map. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
91 lines
3.1 KiB
Python
91 lines
3.1 KiB
Python
"""The LangGraph that holds an Execution (ADR-0003).
|
|
|
|
START -> orchestrator_turn
|
|
orchestrator_turn -> specialist_task x N (Send, parallel) -> orchestrator_turn
|
|
orchestrator_turn -> await_user (interrupt) -> orchestrator_turn
|
|
orchestrator_turn -> finalize -> END
|
|
orchestrator_turn -> end_with_warnings -> END
|
|
|
|
The nodes live in app/nodes/execution_nodes.py; they route with Command and Send, so
|
|
only the fixed edges are declared here.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Mapping
|
|
from pathlib import Path
|
|
from typing import Any, cast
|
|
|
|
from langgraph.graph import END, START, StateGraph
|
|
|
|
from app.adk.runtime import (
|
|
AgentRuntime,
|
|
Decider,
|
|
RoleSpec,
|
|
RunLimiter,
|
|
SubmissionReview,
|
|
ToolFactory,
|
|
)
|
|
from app.nodes.execution_nodes import make_execution_nodes
|
|
from app.nodes.router import OrchestratorPolicy
|
|
from app.recorder import ExecutionRecorder
|
|
from app.states.execution_state import ExecutionState
|
|
|
|
|
|
def build_execution_graph(
|
|
*,
|
|
runtime: AgentRuntime,
|
|
roles: Mapping[str, RoleSpec],
|
|
recorder: ExecutionRecorder,
|
|
output_root: Path,
|
|
max_orchestrator_turns: int = 100,
|
|
tool_factory: ToolFactory | None = None,
|
|
limiter: RunLimiter | None = None,
|
|
skill_versions: Mapping[str, str] | None = None,
|
|
orchestrator: OrchestratorPolicy | None = None,
|
|
submission_review: SubmissionReview | None = None,
|
|
confirm_drafts: bool = False,
|
|
decider: Decider | None = None,
|
|
pillar_threshold: float = 1.5,
|
|
reworded_threshold: float = 0.25,
|
|
guard_user_text: bool = False,
|
|
guard_threshold: float = 0.75,
|
|
skill_references: Mapping[str, Mapping[str, Mapping[str, str]]] | None = None,
|
|
skill_threshold: float = 1.25,
|
|
assess_at_end: bool = False,
|
|
) -> StateGraph:
|
|
nodes = make_execution_nodes(
|
|
runtime=runtime,
|
|
roles=roles,
|
|
recorder=recorder,
|
|
output_root=output_root,
|
|
max_orchestrator_turns=max_orchestrator_turns,
|
|
tool_factory=tool_factory,
|
|
limiter=limiter,
|
|
skill_versions=skill_versions,
|
|
orchestrator=orchestrator,
|
|
submission_review=submission_review,
|
|
confirm_drafts=confirm_drafts,
|
|
decider=decider,
|
|
pillar_threshold=pillar_threshold,
|
|
reworded_threshold=reworded_threshold,
|
|
guard_user_text=guard_user_text,
|
|
guard_threshold=guard_threshold,
|
|
skill_references=skill_references,
|
|
skill_threshold=skill_threshold,
|
|
assess_at_end=assess_at_end,
|
|
)
|
|
|
|
graph = StateGraph(ExecutionState)
|
|
graph.add_node("orchestrator_turn", cast(Any, nodes.orchestrator_turn))
|
|
# Specialist tasks receive their Send payload, not the Execution state.
|
|
graph.add_node("specialist_task", cast(Any, nodes.specialist_task))
|
|
graph.add_node("await_user", cast(Any, nodes.await_user))
|
|
graph.add_node("finalize", cast(Any, nodes.finalize))
|
|
graph.add_node("end_with_warnings", cast(Any, nodes.end_with_warnings))
|
|
graph.add_edge(START, "orchestrator_turn")
|
|
graph.add_edge("specialist_task", "orchestrator_turn")
|
|
graph.add_edge("finalize", END)
|
|
graph.add_edge("end_with_warnings", END)
|
|
return graph
|