dongarandClaude Opus 5.5
83804fe02a
CI / checks (push) Skipped
CI / checks (pull_request) Successful in 1m14s
Development Plan M1.1, as discussed. - Schema v4: a work_items table (id, scope, title, status, outcome, position, data) and an agent row whose active_item points at one (NULL: idle). Canonical events and intents carry their work item, and events their actor. Older stores are refused with a clear message: there was no production data, so no migration (the mechanism stays). - The log is reached through a Transcript bound to one work item and one actor: store.transcript(item, actor) reads only that item and writes with both. The planner, executor, delegation and expert desk get one per call from the orchestrator instead of holding the store, so a component can neither read another task's events (the planner read every earlier task's, #78) nor write without attribution. store.all_events() is kept for readers that span items (evaluation capture, dumps). Intents are begun through the transcript or with work_item=, so each belongs to its item. - The orchestrator opens a work item on 'use', closes it with its outcome (completed or abandoned), and carries what the operator said while idle into the new item as copies with their origin, so a task sent before 'use' is still planned from (D1). control.py keeps its state machine through get_state()/transition(), now over the active work item, until M2.6 retires it. - nisse_dev.dump shows work items and each event's item and actor. Tests: test_work_items.py (scoping, attribution, intent ownership, restart, outcomes, carried messages, a second task never seeing the first); the suites updated for the per-call transcript. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PPQ14L3LikyefCMFBqEbKE
99 lines
3.6 KiB
Python
99 lines
3.6 KiB
Python
"""End-to-end milestone against real models: plan with the planner role,
|
|
approve through the gate, then let the executor role actually create and test
|
|
a file on disk.
|
|
|
|
Uses the test config's planner model for every role: it needs a model that
|
|
holds the tool-call contract on both ends.
|
|
"""
|
|
|
|
import io
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from nisse_dev.control import (
|
|
AWAIT_ARCH_SIGNOFF,
|
|
AWAIT_INPUT,
|
|
AWAIT_MILESTONE_SIGNOFF,
|
|
EXECUTING,
|
|
PR_OPEN,
|
|
Orchestrator,
|
|
)
|
|
from nisse_dev.executor import LLMExecutor
|
|
from nisse_dev.llm import LiteLLMClient, RoleMap
|
|
from nisse_dev.oplog import OpLog
|
|
from nisse_dev.planner import LLMPlanningAgent
|
|
from nisse_dev.state import StateStore
|
|
from nisse_dev.tools import Workspace
|
|
from nisse_dev.transport import InMemoryTransport
|
|
|
|
pytestmark = pytest.mark.integration
|
|
|
|
|
|
def _drive_to_execution(
|
|
store: StateStore, transport: InMemoryTransport, max_steps: int = 10
|
|
) -> None:
|
|
"""Play the operator. A scripted approve/approve/start sequence is not
|
|
robust against a live model: ask_human is a legitimate move at any gate,
|
|
and a question shifts the state machine under a fixed script. So respond
|
|
to whatever the agent actually did."""
|
|
for _ in range(max_steps):
|
|
state = store.get_state()
|
|
assert state is not None
|
|
if state.state == EXECUTING:
|
|
return
|
|
gate = state.data.get("gate") or {}
|
|
if state.state == AWAIT_INPUT:
|
|
transport.receive("don", "Use your best judgement and proceed.")
|
|
elif state.state == AWAIT_MILESTONE_SIGNOFF and gate.get("approved"):
|
|
# The milestone runs to completion inside this command.
|
|
transport.receive("don", "start milestone 1")
|
|
return
|
|
elif state.state in (AWAIT_ARCH_SIGNOFF, AWAIT_MILESTONE_SIGNOFF):
|
|
transport.receive("don", "approve")
|
|
else:
|
|
raise AssertionError(f"unexpected state {state.state}")
|
|
raise AssertionError(
|
|
f"never reached execution; last message: {transport.outbound[-1]}"
|
|
)
|
|
|
|
|
|
def test_plan_approve_execute_produces_a_real_file(
|
|
tmp_path: Path, litellm: LiteLLMClient, live_model: str
|
|
) -> None:
|
|
# Both roles use the capable model here: the point is the whole gated
|
|
# loop over a real proxy, not local-model competence (measured separately).
|
|
model = live_model
|
|
roles = RoleMap(executor=model, planner=model, helper=model, expert=model)
|
|
client = litellm
|
|
store = StateStore(tmp_path / "state.db", oplog=OpLog("nisse-dev", io.StringIO()))
|
|
workspace = Workspace(tmp_path / "work", timeout_s=60)
|
|
transport = InMemoryTransport()
|
|
orchestrator = Orchestrator(
|
|
store,
|
|
transport,
|
|
LLMPlanningAgent(client, roles),
|
|
operators={"don"},
|
|
roles=roles,
|
|
executor=LLMExecutor(client, roles, workspace, max_turns=10),
|
|
)
|
|
orchestrator.start()
|
|
|
|
transport.receive(
|
|
"don",
|
|
"use greet. Milestone 1: create greet.py in the workspace root defining "
|
|
"greet(name) returning 'Hello, <name>!', and verify it by running python.",
|
|
)
|
|
_drive_to_execution(store, transport)
|
|
|
|
state = store.get_state()
|
|
assert state is not None
|
|
# Never EXECUTING at rest: with no publisher a finished milestone waits in
|
|
# PR_OPEN, and one that stopped short waits for the operator.
|
|
assert state.state in (PR_OPEN, AWAIT_INPUT)
|
|
|
|
created = list(workspace.root.rglob("*.py"))
|
|
assert created, f"executor created no Python file; said: {transport.outbound[-1]}"
|
|
combined = "\n".join(p.read_text() for p in created)
|
|
assert "def greet" in combined
|