chore: housekeeping from the runs of 2026-10-09
Some checks failed
validation / verify (push) Failing after 12s

- An Execution's files are written as each Deliverable is submitted, marked
  in_progress, so a killed process or one waiting for its user leaves them on
  disk. A write removes files an earlier write left that it no longer has.
- A question about delivered work is answered from that Execution's solution
  guide by the reply writer; a question about the service is answered as
  before. Nothing is started for either.
- Lessons: prove writes only for lessons the Skill holds; the Skill records
  the vendored Skill versions the lessons were read against, status names any
  that changed, and a test fails until they are reviewed.
- Four more code patterns: Firestore, BigQuery, Eventarc and GKE.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-10 11:44:38 +01:00
parent 10d23a5f91
commit 71da0ed504
24 changed files with 1109 additions and 43 deletions

View File

@@ -62,3 +62,100 @@ async def test_a_change_needs_something_delivered_to_change(tmp_path):
assert "- Design thing 1." in decider.asked[0][0]
assert "Design thing 2." not in decider.asked[0][0] # still in progress
assert without.kind == NEW_REQUEST and no_case.kind == NEW_REQUEST
# --- a question about what was delivered ------------------------------------------------
async def test_a_question_about_delivered_work_is_told_from_one_about_the_service(
tmp_path,
):
delivered(tmp_path, "acme", ["completed"])
about = FakeDecider(
{"intake": Answer(QUESTION, 0.98), "about_delivered": Answer(0.9, 0.9)}
)
general = FakeDecider(
{"intake": Answer(QUESTION, 0.98), "about_delivered": Answer(0.1, 0.9)}
)
first = await Intake(about, tmp_path).read("Why Cloud SQL?", "acme")
second = await Intake(general, tmp_path).read("What can you do?", "acme")
assert first.kind == QUESTION and first.about_delivered and first.latest == "v1"
assert second.kind == QUESTION and not second.about_delivered
async def test_with_nothing_delivered_a_question_is_never_about_delivered_work(
tmp_path,
):
decider = FakeDecider(
{"intake": Answer(QUESTION, 0.98), "about_delivered": Answer(0.99, 0.9)}
)
reading = await Intake(decider, tmp_path).read("Why Cloud SQL?", "new-client")
assert not reading.about_delivered
assert len(decider.asked) == 1 # the second question was not asked
async def test_an_answer_is_written_from_the_delivered_guide_and_nothing_else(
tmp_path,
):
from langgraph.checkpoint.memory import InMemorySaver
from app.adk.fake_runtime import Call, FakeAgentRuntime, sample_submission
from app.adk.runtime import RoleSpec
from app.agent import ExecutionEngine
from app.nodes.intake import DeliveredAnswers
from app.nodes.router import Router, Thresholds
from app.recorder import InMemoryRecorder
from app.workflows.deliverables import DEPENDENCY_GRAPH
roles = {
"orchestrator": RoleSpec("orchestrator", "Unused.", budget=40),
**{
spec.specialist: RoleSpec(spec.specialist, "Produce.", budget=15)
for spec in DEPENDENCY_GRAPH.values()
},
}
seen: dict = {}
def writer(task):
seen.update(task.context)
return [Call("write_reply", {"text": "Cloud SQL, for relational bookings."})]
runtime = FakeAgentRuntime(
{
**{
spec.specialist: [[sample_submission(kind)]]
for kind, spec in DEPENDENCY_GRAPH.items()
},
"reply-writer": [writer],
}
)
engine = ExecutionEngine(
runtime=runtime,
roles=roles,
recorder=InMemoryRecorder(),
checkpointer=InMemorySaver(),
output_root=tmp_path,
orchestrator=Router(NoDecider(), None, Thresholds()),
)
await engine.start(
"Design bookings.", customer_case="acme", pre_approved=True, execution_id="v1"
)
runs_before = len(runtime.runs)
answers = DeliveredAnswers(
runtime, RoleSpec("reply-writer", "Write.", budget=3), tmp_path
)
answer = await answers.answer("Why Cloud SQL?", "acme", "v1")
assert answer == "Cloud SQL, for relational bookings."
assert seen["question"] == "Why Cloud SQL?"
assert seen["delivered"]["execution_id"] == "v1"
assert seen["delivered"]["request"] == "Design bookings."
assert seen["delivered"]["solution_guide"]
assert len(runtime.runs) == runs_before + 1 # one writer run; no Execution
# An Execution that is not there gives no answer, not an error.
assert await answers.answer("Why?", "acme", "missing") is None

View File

@@ -0,0 +1,100 @@
"""An Execution's files are on disk as soon as each Deliverable is submitted.
Before this they were written only when an Execution ended, so a process that was
killed, or an Execution left waiting for its user, had nothing to show.
"""
import json
from langgraph.checkpoint.memory import InMemorySaver
from app.adk.fake_runtime import FakeAgentRuntime, sample_submission
from app.adk.runtime import NoDecider, RoleSpec
from app.agent import ExecutionEngine
from app.baseline import BaselineError, load_baseline
from app.nodes.execution_nodes import _write_outputs
from app.nodes.router import Router, Thresholds
from app.recorder import InMemoryRecorder
from app.states.ledger import Ledger
from app.workflows.deliverables import DEPENDENCY_GRAPH
ROLES = {
"orchestrator": RoleSpec("orchestrator", "Unused.", budget=40),
**{
spec.specialist: RoleSpec(spec.specialist, "Produce.", budget=15)
for spec in DEPENDENCY_GRAPH.values()
},
}
def folder(tmp_path, execution_id: str):
return tmp_path / "deliverables" / "cases" / "acme" / "executions" / execution_id
async def test_an_execution_waiting_for_its_user_has_written_what_exists(tmp_path):
engine = ExecutionEngine(
runtime=FakeAgentRuntime(
{
spec.specialist: [[sample_submission(kind)]]
for kind, spec in DEPENDENCY_GRAPH.items()
}
),
roles=ROLES,
recorder=InMemoryRecorder(),
checkpointer=InMemorySaver(),
output_root=tmp_path,
orchestrator=Router(NoDecider(), None, Thresholds()),
)
waiting = await engine.start("Ingest", customer_case="acme", execution_id="v1")
# It stopped for the first Approval: only the first Phase has been produced.
assert waiting.status == "awaiting_user"
out = folder(tmp_path, "v1")
manifest = json.loads((out / "execution.json").read_text())
assert manifest["status"] == "in_progress"
assert set(manifest["deliverables"]) == {"requirements", "technical_decomposition"}
assert (out / "deliverables" / "requirements.md").read_text()
assert (out / "requirements.json").is_file()
assert manifest["solution_guide"] is None
# Unfinished work is never something a Change request can start from.
try:
load_baseline(tmp_path, "acme", "v1")
except BaselineError as refused:
assert "did not complete (in_progress)" in str(refused)
else:
raise AssertionError("an in-progress Execution was accepted as a Baseline")
def test_a_file_an_earlier_write_left_is_removed_with_the_revision(tmp_path):
state = {
"execution_id": "v1",
"customer_case": "acme",
"workflow_request": "Ingest",
"deliverables": {
"deployment_guidance": {
"content": "guide",
"attachments": {
"terraform/main.tf": "one",
"terraform/queue.tf": "two",
},
}
},
}
out = folder(tmp_path, "v1")
_write_outputs(tmp_path, state, "in_progress", Ledger())
assert (out / "terraform" / "queue.tf").is_file()
(out / "notes.txt").write_text("a person's own file")
# The Revision folded the queue into main.tf.
state["deliverables"]["deployment_guidance"]["attachments"] = {
"terraform/main.tf": "one and two"
}
_write_outputs(tmp_path, state, "completed", Ledger())
assert not (out / "terraform" / "queue.tf").exists()
assert (out / "terraform" / "main.tf").read_text() == "one and two"
# Only files this Execution wrote are ever removed.
assert (out / "notes.txt").is_file()
assert json.loads((out / "execution.json").read_text())["status"] == "completed"