flurdy/agent-skills / skills/plan-to-backlog
plan-to-backlog
VerifiedMaterialize an approved cited plan into proportionate Beads tracking when the user asks for durable ownership. Recommends no item, one item, or a bounded epic; checks owners and duplicates; previews every write; applies only after exact confirmation.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 19.0 KB |
| references/contract.md | markdown | 19.0 KB |
| scripts/confirmed-bd.shexecutable | script | 5.5 KB |
| scripts/sha256-stdin.shexecutable | script | 893 B |
| scripts/utc-now.shexecutable | script | 150 B |
| tests/fixtures/decision-boundary-scenarios.json | config | 23.0 KB |
| tests/fixtures/decision-scenarios.json | config | 20.6 KB |
| tests/test-helpers.shexecutable | script | 9.9 KB |
| tests/test-skill-contract.shexecutable | script | 5.9 KB |
| tests/test_decision_fixtures.py | script | 34.2 KB |
tests/test_decision_fixtures.py
View on GitHub#!/usr/bin/env python3
"""Evidence-derived invariants for frozen plan-to-backlog decision fixtures.
These checks exercise a deterministic policy oracle over captured scenarios. Live model
behavior remains nondeterministic and is recorded separately as dogfood evidence.
"""
from __future__ import annotations
import copy
import json
import re
import unittest
from pathlib import Path
from typing import Any
FIXTURE_ROOT = Path(__file__).resolve().parent / "fixtures"
FIXTURE_NAMES = {"decision-boundary-scenarios.json", "decision-scenarios.json"}
OUTCOME_CHECKS = (
"observable",
"ownAcceptance",
"independentValue",
"independentLifecycle",
"outcomeLanguage",
)
MECHANICAL_TITLE_PATTERN = re.compile(r"\b(test|review|commit|retry|handoff)\b", re.IGNORECASE)
SEQUENCE_RATIONALE_TERMS = ("planning order", "do first", "then implement", "work sequence")
SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
ALLOWED_WRITE_ACTIONS = {"create", "update-type", "set-parent", "add-blocker"}
REQUIRED_MATRIX = {
"no-item-existing-owner": ("ready", "no-item"),
"mechanical-single-outcome": ("ready", "single-item"),
"bounded-epic-conversion": ("ready", "epic"),
"tightly-coupled-two-outcomes": ("ready", "single-item"),
"cross-repository-two-outcomes": ("ready", "epic"),
"existing-duplicate-tree": ("ready", "no-item"),
"partially-materialized-tree": ("ready", "epic"),
"unresolved-plan": ("needs-clarification", None),
"unapproved-plan": ("needs-clarification", None),
"declined-apply": ("ready", "single-item"),
"partial-failure-recovery": ("ready", "epic"),
"mechanical-dependency-sequence": ("ready", "epic"),
"more-than-six-candidates": ("needs-clarification", None),
"duplicate-reuse": ("ready", "no-item"),
}
def load_scenarios() -> list[dict[str, Any]]:
paths = sorted(FIXTURE_ROOT.glob("decision-*.json"))
if {path.name for path in paths} != FIXTURE_NAMES:
raise ValueError("fixture directory contains missing or unreferenced decision files")
scenarios: list[dict[str, Any]] = []
for path in paths:
payload = json.loads(path.read_text(encoding="utf-8"))
if payload.get("scenarioVersion") != 1:
raise ValueError(f"unsupported scenarioVersion in {path.name}")
if not isinstance(payload.get("scenarios"), list):
raise ValueError(f"scenarios must be a list in {path.name}")
scenarios.extend(payload["scenarios"])
identifiers = [scenario.get("id") for scenario in scenarios]
if len(identifiers) != len(set(identifiers)):
raise ValueError("scenario IDs must be unique")
return scenarios
def qualifying_outcomes(scenario_input: dict[str, Any]) -> list[dict[str, Any]]:
return [
outcome
for outcome in scenario_input.get("candidateOutcomes", [])
if all(outcome.get(check) is True for check in OUTCOME_CHECKS)
]
def has_two_outcome_epic_boundary(
scenario_input: dict[str, Any], outcomes: list[dict[str, Any]]
) -> bool:
repositories = {outcome.get("repository") for outcome in outcomes}
return (
len(outcomes) == 2
and None not in repositories
and len(repositories) == 2
and all(outcome.get("independentlyShippable") is True for outcome in outcomes)
and bool(scenario_input.get("aggregateOwnershipEvidence", "").strip())
)
def derive_decision(scenario_input: dict[str, Any]) -> tuple[str, str | None]:
source = scenario_input["source"]
if not source.get("approved") or scenario_input.get("unresolvedQuestions"):
return "needs-clarification", None
owners = [
item
for item in scenario_input.get("existingItems", [])
if item.get("classification") == "owner"
]
if len(owners) > 1:
return "needs-clarification", None
if owners and owners[0].get("exactCompleteOutcome"):
return "ready", "no-item"
candidates = scenario_input.get("candidateOutcomes", [])
if not candidates:
return "needs-clarification", None
outcomes = qualifying_outcomes(scenario_input)
if len(outcomes) > 6:
return "needs-clarification", None
if len(outcomes) <= 1:
return "ready", "single-item"
if len(outcomes) == 2:
disposition = "epic" if has_two_outcome_epic_boundary(scenario_input, outcomes) else "single-item"
return "ready", disposition
return "ready", "epic"
def operation_key(write: dict[str, Any]) -> tuple[Any, ...]:
action = write.get("action")
if action == "create":
return action, write.get("ref"), write.get("parent")
if action == "update-type":
return action, write.get("ref")
if action == "set-parent":
return action, write.get("ref"), write.get("parent")
if action == "add-blocker":
return action, write.get("dependent"), write.get("prerequisite")
return action,
def existing_proposal_ref(item: dict[str, Any]) -> str | None:
if item.get("proposalRef"):
return item["proposalRef"]
if item.get("classification") == "owner":
return "owner"
return None
def validate_traceability(scenario: dict[str, Any], errors: list[str]) -> None:
source = scenario["input"]["source"]
if not SHA256_PATTERN.fullmatch(source.get("fingerprint", "")):
errors.append("source fingerprint is not lowercase SHA-256")
for item in scenario["expected"]["items"]:
if item["action"] != "create":
continue
expected_metadata = {
"plan_source": source["locator"],
"plan_source_sha256": source["fingerprint"],
"plan_proposal_ref": item["ref"],
}
if item.get("metadata") != expected_metadata:
errors.append(f"{item['ref']} create metadata is not source-traceable")
if item.get("sourceCitation") != f"Source plan: {source['locator']}":
errors.append(f"{item['ref']} create lacks the exact source citation")
def validate_write_set(scenario: dict[str, Any], errors: list[str]) -> None:
expected = scenario["expected"]
items = expected["items"]
item_refs = [item["ref"] for item in items]
if len(item_refs) != len(set(item_refs)):
errors.append("proposal item refs are not unique")
declared_refs = set(item_refs)
relationships = expected["relationships"]
for relationship in relationships:
if relationship.get("from") not in declared_refs or relationship.get("to") not in declared_refs:
errors.append("relationship references an undeclared proposal ref")
writes = expected["logicalWrites"]
write_keys = [operation_key(write) for write in writes]
if len(write_keys) != len(set(write_keys)):
errors.append("logical write set contains duplicate operations")
for write in writes:
if write.get("action") not in ALLOWED_WRITE_ACTIONS:
errors.append(f"logical write set contains unsupported action {write.get('action')}")
required_item_writes = []
for item in items:
if item["action"] == "create":
parent = "owner" if item["ref"].startswith("child-") else None
required_item_writes.append(operation_key({"action": "create", "ref": item["ref"], "parent": parent}))
elif item["action"] == "update-type":
required_item_writes.append(("update-type", item["ref"]))
elif item["action"] not in {"reuse"}:
errors.append(f"unsupported item action {item['action']}")
actual_item_writes = [
key for key in write_keys if key[0] in {"create", "update-type", "set-parent"}
]
if actual_item_writes != required_item_writes:
errors.append("logical item writes do not exactly match proposed item actions")
blocker_keys = [
("add-blocker", relationship["from"], relationship["to"])
for relationship in relationships
if relationship["kind"] == "blocking"
]
actual_blocker_keys = [key for key in write_keys if key[0] == "add-blocker"]
if actual_blocker_keys != blocker_keys:
errors.append("logical blocker writes do not exactly match proposed blocking relationships")
parent_refs = {
relationship["from"]
for relationship in relationships
if relationship["kind"] == "parent" and relationship["to"] == "owner"
}
created_children = {item["ref"] for item in items if item["action"] == "create" and item["ref"].startswith("child-")}
if not created_children.issubset(parent_refs):
errors.append("created child lacks a proposed parent relationship")
def validate_epic(scenario: dict[str, Any], errors: list[str]) -> None:
expected = scenario["expected"]
if expected["disposition"] != "epic":
return
children = [item for item in expected["items"] if item["ref"].startswith("child-")]
if not 2 <= len(children) <= 6:
errors.append("epic child count is outside the bounded threshold")
candidate_by_ref = {
candidate["ref"]: candidate
for candidate in scenario["input"].get("candidateOutcomes", [])
}
for child in children:
candidate = candidate_by_ref.get(child["ref"], {})
missing = [check for check in OUTCOME_CHECKS if candidate.get(check) is not True]
if missing:
errors.append(f"{child['ref']} lacks independent-outcome checks: {missing}")
if MECHANICAL_TITLE_PATTERN.search(child["title"]):
errors.append(f"{child['ref']} uses a mechanical child title")
if len(children) == 2 and not has_two_outcome_epic_boundary(
scenario["input"], list(candidate_by_ref.values())
):
errors.append("two-child epic lacks evidenced cross-repository boundaries")
parent_refs = {
relationship["from"]
for relationship in expected["relationships"]
if relationship["kind"] == "parent" and relationship["to"] == "owner"
}
if parent_refs != {child["ref"] for child in children}:
errors.append("epic parent relationships do not match all children")
declared_refs = {item["ref"] for item in expected["items"]}
for relationship in expected["relationships"]:
if relationship["kind"] != "blocking":
continue
if relationship["from"] not in declared_refs or relationship["to"] not in declared_refs:
errors.append("blocking relationship references an undeclared proposal ref")
if not relationship.get("acceptanceCondition"):
errors.append("blocking relationship lacks an acceptance condition")
rationale = relationship.get("rationale", "").casefold()
if not any(term in rationale for term in ("cannot", "until", "requires")):
errors.append("blocking relationship does not state an acceptance dependency")
if any(term in rationale for term in SEQUENCE_RATIONALE_TERMS):
errors.append("blocking relationship represents plan-step sequencing")
evidenced_blockers = [
(candidate["ref"], prerequisite)
for candidate in scenario["input"].get("candidateOutcomes", [])
for prerequisite in candidate.get("acceptanceRequires", [])
]
proposed_blockers = [
(relationship["from"], relationship["to"])
for relationship in expected["relationships"]
if relationship["kind"] == "blocking"
]
if proposed_blockers != evidenced_blockers:
errors.append("blocking relationships do not match source acceptance dependencies")
def validate_no_mutation_paths(scenario: dict[str, Any], errors: list[str]) -> None:
expected = scenario["expected"]
decision = scenario["confirmation"]["decision"]
observed = scenario["observed"]
if expected["disposition"] == "no-item" or expected["readiness"] == "needs-clarification":
if expected["logicalWrites"]:
errors.append("read-only decision contains logical writes")
if observed["writeCalls"]:
errors.append("read-only decision observed writes")
if expected["readiness"] == "needs-clarification":
if decision != "unavailable":
errors.append("needs-clarification decision exposed apply confirmation")
if observed["ledger"]:
errors.append("needs-clarification decision recorded a result ledger")
if decision == "proposal-only":
expected_ledger = {
item["ref"]: ("reused", item.get("existingId"))
for item in expected["items"]
if item["action"] == "reuse"
}
actual_ledger = {
row["ref"]: (row["status"], row.get("actualId"))
for row in observed["ledger"]
}
if len(actual_ledger) != len(observed["ledger"]) or actual_ledger != expected_ledger:
errors.append("proposal-only ledger does not exactly match reused nodes")
if expected["disposition"] == "no-item":
if decision != "not-required":
errors.append("no-item decision exposed apply confirmation")
expected_ledger = {}
for item in scenario["input"].get("existingItems", []):
ref = existing_proposal_ref(item) or item.get("proposalRef")
if not ref or item.get("classification") not in {
"owner",
"owner-node",
"duplicate",
"duplicate-node",
}:
continue
status = "reused" if item["classification"] in {"owner", "owner-node"} else "skipped"
expected_ledger[ref] = (status, item["id"])
actual_ledger = {
row["ref"]: (row["status"], row.get("actualId"))
for row in observed["ledger"]
}
if len(actual_ledger) != len(observed["ledger"]) or actual_ledger != expected_ledger:
errors.append("no-item ledger does not exactly match classified existing nodes")
if decision == "decline":
if observed["writeCalls"]:
errors.append("declined proposal observed writes")
item_refs = {item["ref"] for item in expected["items"]}
ledger_refs = {row["ref"] for row in observed["ledger"]}
if len(ledger_refs) != len(observed["ledger"]) or ledger_refs != item_refs or any(
row["status"] != "declined" or row.get("actualId") is not None
for row in observed["ledger"]
):
errors.append("declined proposal ledger is not exact")
def validate_observed_apply(scenario: dict[str, Any], errors: list[str]) -> None:
observed = scenario["observed"]
calls = observed["writeCalls"]
decision = scenario["confirmation"]["decision"]
if not calls:
if decision == "apply" and scenario["expected"]["logicalWrites"]:
errors.append("confirmed apply lacks observed operations")
return
if decision != "apply":
errors.append("writes were observed without apply confirmation")
return
expected_keys = [operation_key(write) for write in scenario["expected"]["logicalWrites"]]
observed_keys = [operation_key(call) for call in calls]
if observed_keys != expected_keys:
errors.append("observed operations do not match the full confirmed apply sequence")
ledger_by_ref = {row["ref"]: row for row in observed["ledger"]}
if len(ledger_by_ref) != len(observed["ledger"]):
errors.append("result ledger contains duplicate refs")
call_refs = {call.get("ref") for call in calls}
if set(ledger_by_ref) != call_refs:
errors.append("result ledger refs do not exactly match observed operations")
for call in calls:
row = ledger_by_ref.get(call.get("ref"))
if not row:
errors.append(f"observed {call.get('ref')} call lacks a ledger row")
continue
if row.get("status") != call.get("status") or row.get("actualId") != call.get("actualId"):
errors.append(f"observed {call.get('ref')} call disagrees with its ledger row")
if call.get("status") == "created" and not call.get("actualId"):
errors.append(f"created {call.get('ref')} call lacks an actual ID")
if call.get("status") in {"failed", "skipped"} and call.get("actualId") is not None:
errors.append(f"{call.get('status')} {call.get('ref')} call unexpectedly has an actual ID")
def validate_existing_reuse(scenario: dict[str, Any], errors: list[str]) -> None:
authoritative = [
item
for item in scenario["input"].get("existingItems", [])
if item.get("classification") in {"owner", "owner-node"}
and existing_proposal_ref(item)
]
if not authoritative:
return
evidenced_ids = {existing_proposal_ref(item): item["id"] for item in authoritative}
proposed_ids = {
item["ref"]: item.get("existingId")
for item in scenario["expected"]["items"]
if item["action"] in {"reuse", "update-type"}
}
if proposed_ids != evidenced_ids:
errors.append("proposed existing IDs do not exactly match authoritative source nodes")
expected_reuse = {
item["ref"]: item.get("existingId")
for item in scenario["expected"]["items"]
if item["action"] == "reuse"
}
ledger_reuse = {
row["ref"]: row.get("actualId")
for row in scenario["observed"]["ledger"]
if row["status"] == "reused"
}
if ledger_reuse != expected_reuse:
errors.append("reuse ledger does not exactly match proposed existing nodes")
evidenced_parents = {
(existing_proposal_ref(item), item["parentProposalRef"])
for item in authoritative
if item.get("parentProposalRef")
}
proposed_parents = {
(relationship["from"], relationship["to"])
for relationship in scenario["expected"]["relationships"]
if relationship["kind"] == "parent" and relationship["from"] in evidenced_ids
}
if proposed_parents != evidenced_parents:
errors.append("proposed reuse topology does not match authoritative source nodes")
def validate_duplicate_reuse(scenario: dict[str, Any], errors: list[str]) -> None:
if "duplicate" not in scenario["covers"]:
return
existing = scenario["input"]["existingItems"]
authoritative = [
item for item in existing if item["classification"] in {"owner", "owner-node"}
]
duplicates = [
item for item in existing if item["classification"] in {"duplicate", "duplicate-node"}
]
if len([item for item in authoritative if item["classification"] == "owner"]) != 1 or not duplicates:
errors.append("duplicate fixture lacks one authoritative owner/tree and a duplicate")
return
expected_reuse = {
(item.get("proposalRef") or "owner"): item["id"]
for item in authoritative
if item.get("proposalRef") or item["classification"] == "owner"
}
actual_reuse = {
item["ref"]: item.get("existingId")
for item in scenario["expected"]["items"]
if item["action"] == "reuse"
}
if actual_reuse != expected_reuse:
errors.append("duplicate fixture did not reuse the complete authoritative owner tree")
duplicate_ids = {item["id"] for item in duplicates}
if duplicate_ids & set(actual_reuse.values()):
errors.append("duplicate fixture reused a non-authoritative tree node")
if scenario["expected"]["logicalWrites"]:
errors.append("duplicate reuse fixture proposes mutation")
def validate_partial_materialization(scenario: dict[str, Any], errors: list[str]) -> None:
if "partial-materialization" not in scenario["covers"]:
return
existing_refs = {
item["proposalRef"]
for item in scenario["input"]["existingItems"]
if item["classification"] in {"owner", "owner-node"}
}
candidate_refs = {
candidate["ref"] for candidate in scenario["input"]["candidateOutcomes"]
}
expected_reuse_refs = {
item["ref"] for item in scenario["expected"]["items"] if item["action"] == "reuse"
}
create_refs = {
item["ref"] for item in scenario["expected"]["items"] if item["action"] == "create"
}
if expected_reuse_refs != existing_refs:
errors.append("partial rerun does not reuse every existing proposal ref")
if create_refs != candidate_refs - existing_refs:
errors.append("partial rerun does not create exactly the missing outcome refs")
if create_refs & existing_refs:
errors.append("partial rerun would duplicate an existing proposal ref")
def validate_partial_recovery(scenario: dict[str, Any], errors: list[str]) -> None:
if "partial-failure" not in scenario["covers"]:
return
calls = scenario["observed"]["writeCalls"]
ledger = scenario["observed"]["ledger"]
statuses = {row["status"] for row in ledger}
if not {"created", "failed", "skipped"}.issubset(statuses):
errors.append("partial-failure ledger lacks created, failed, and skipped states")
successful = {
row["ref"]: row["actualId"]
for row in ledger
if row["status"] in {"created", "reused", "updated"} and row.get("actualId")
}
recovery = scenario.get("recovery", {})
if recovery.get("reuseMappings") != successful:
errors.append("recovery does not preserve every successful actual ID")
recovery_keys = [operation_key(write) for write in recovery.get("logicalWrites", [])]
retry_keys = [
operation_key(call) for call in calls if call.get("status") in {"failed", "skipped"}
]
if recovery_keys != retry_keys:
errors.append("recovery write set does not match failed/skipped operations")
successful_refs = set(successful)
recovery_create_refs = {
write.get("ref")
for write in recovery.get("logicalWrites", [])
if write.get("action") == "create"
}
if recovery_create_refs & successful_refs:
errors.append("recovery would duplicate a successful item")
def validate_mechanical_sequence(scenario: dict[str, Any], errors: list[str]) -> None:
if "mechanical-sequence" not in scenario["covers"]:
return
if not scenario["input"].get("planSequence"):
errors.append("mechanical-sequence fixture lacks a source sequence")
if any(
relationship["kind"] == "blocking"
for relationship in scenario["expected"]["relationships"]
):
errors.append("mechanical plan sequence produced a blocking edge")
def validate_scenario(scenario: dict[str, Any]) -> list[str]:
errors: list[str] = []
expected = scenario["expected"]
readiness, disposition = derive_decision(scenario["input"])
if (expected["readiness"], expected["disposition"]) != (readiness, disposition):
errors.append(
"expected decision does not match policy oracle: "
f"{expected['readiness']}/{expected['disposition']} != {readiness}/{disposition}"
)
validate_traceability(scenario, errors)
validate_write_set(scenario, errors)
validate_epic(scenario, errors)
validate_no_mutation_paths(scenario, errors)
validate_observed_apply(scenario, errors)
validate_existing_reuse(scenario, errors)
validate_duplicate_reuse(scenario, errors)
validate_partial_materialization(scenario, errors)
validate_partial_recovery(scenario, errors)
validate_mechanical_sequence(scenario, errors)
return errors
class PlanToBacklogDecisionFixtureTest(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
cls.scenarios = load_scenarios()
cls.by_id = {scenario["id"]: scenario for scenario in cls.scenarios}
def test_frozen_scenarios_satisfy_policy_contract(self) -> None:
self.assertEqual(set(REQUIRED_MATRIX), set(self.by_id))
failures = {
scenario["id"]: errors
for scenario in self.scenarios
if (errors := validate_scenario(scenario))
}
self.assertEqual({}, failures)
def test_required_matrix_has_expected_decisions(self) -> None:
actual = {
identifier: derive_decision(self.by_id[identifier]["input"])
for identifier in REQUIRED_MATRIX
}
self.assertEqual(REQUIRED_MATRIX, actual)
def test_mechanical_steps_do_not_create_children(self) -> None:
scenario = self.by_id["mechanical-single-outcome"]
self.assertGreater(len(scenario["input"]["mechanicalSteps"]), 1)
self.assertEqual(("ready", "single-item"), derive_decision(scenario["input"]))
self.assertEqual(["owner"], [item["ref"] for item in scenario["expected"]["items"]])
def test_tightly_coupled_two_outcomes_collapse(self) -> None:
scenario = self.by_id["tightly-coupled-two-outcomes"]
self.assertEqual(2, len(scenario["input"]["candidateOutcomes"]))
self.assertEqual(("ready", "single-item"), derive_decision(scenario["input"]))
self.assertFalse(has_two_outcome_epic_boundary(scenario["input"], qualifying_outcomes(scenario["input"])))
def test_two_outcome_epic_requires_evidenced_cross_repository_boundaries(self) -> None:
scenario_input = copy.deepcopy(self.by_id["cross-repository-two-outcomes"]["input"])
self.assertEqual(("ready", "epic"), derive_decision(scenario_input))
scenario_input["aggregateOwnershipEvidence"] = ""
self.assertEqual(("ready", "single-item"), derive_decision(scenario_input))
scenario_input = copy.deepcopy(self.by_id["cross-repository-two-outcomes"]["input"])
scenario_input["candidateOutcomes"][1]["repository"] = "api"
self.assertEqual(("ready", "single-item"), derive_decision(scenario_input))
def test_duplicate_tree_reuses_every_authoritative_node(self) -> None:
scenario = self.by_id["existing-duplicate-tree"]
self.assertEqual([], validate_scenario(scenario))
self.assertEqual([], scenario["expected"]["logicalWrites"])
self.assertEqual(3, len(scenario["expected"]["items"]))
def test_partial_tree_proposes_only_missing_actions(self) -> None:
scenario = self.by_id["partially-materialized-tree"]
self.assertEqual([], validate_scenario(scenario))
self.assertEqual(
[("create", "child-2", "owner"), ("add-blocker", "child-2", "child-1")],
[operation_key(write) for write in scenario["expected"]["logicalWrites"]],
)
def test_more_than_six_outcomes_requires_clarification(self) -> None:
scenario = self.by_id["more-than-six-candidates"]
self.assertEqual(7, len(qualifying_outcomes(scenario["input"])))
self.assertEqual(("needs-clarification", None), derive_decision(scenario["input"]))
self.assertEqual([], scenario["expected"]["logicalWrites"])
def test_ambiguous_owners_require_clarification(self) -> None:
scenario_input = copy.deepcopy(self.by_id["no-item-existing-owner"]["input"])
scenario_input["existingItems"].append(
{
"id": "fixture-102",
"classification": "owner",
"exactCompleteOutcome": True,
"matchEvidence": "Competing complete owner",
}
)
self.assertEqual(("needs-clarification", None), derive_decision(scenario_input))
def test_recovery_requires_every_failed_and_skipped_operation(self) -> None:
scenario = copy.deepcopy(self.by_id["partial-failure-recovery"])
scenario["recovery"]["logicalWrites"].pop()
self.assertIn(
"recovery write set does not match failed/skipped operations",
validate_scenario(scenario),
)
def test_recovery_preserves_confirmed_parent_and_dependency_refs(self) -> None:
scenario = copy.deepcopy(self.by_id["partial-failure-recovery"])
scenario["recovery"]["logicalWrites"][0]["parent"] = "bogus-owner"
scenario["recovery"]["logicalWrites"][1]["prerequisite"] = "bogus-child"
self.assertIn(
"recovery write set does not match failed/skipped operations",
validate_scenario(scenario),
)
def test_observed_apply_must_match_the_confirmed_write_set(self) -> None:
scenario = copy.deepcopy(self.by_id["partial-failure-recovery"])
scenario["observed"]["writeCalls"].pop(1)
self.assertIn(
"observed operations do not match the full confirmed apply sequence",
validate_scenario(scenario),
)
scenario = copy.deepcopy(self.by_id["partial-failure-recovery"])
scenario["observed"]["writeCalls"].append(
{"action": "delete", "ref": "owner", "status": "failed", "actualId": None}
)
self.assertIn(
"observed operations do not match the full confirmed apply sequence",
validate_scenario(scenario),
)
def test_extra_ledger_rows_are_rejected(self) -> None:
scenario = copy.deepcopy(self.by_id["partial-failure-recovery"])
scenario["observed"]["ledger"].append(
{"ref": "ghost", "status": "failed", "actualId": None}
)
self.assertIn(
"result ledger refs do not exactly match observed operations",
validate_scenario(scenario),
)
def test_read_only_ledgers_are_exact(self) -> None:
scenario = copy.deepcopy(self.by_id["unapproved-plan"])
scenario["confirmation"]["decision"] = "apply"
scenario["observed"]["ledger"].append(
{"ref": "owner", "status": "created", "actualId": "fixture-999"}
)
errors = validate_scenario(scenario)
self.assertIn("needs-clarification decision exposed apply confirmation", errors)
self.assertIn("needs-clarification decision recorded a result ledger", errors)
scenario = copy.deepcopy(self.by_id["declined-apply"])
scenario["observed"]["ledger"][0]["ref"] = "forged-ref"
self.assertIn("declined proposal ledger is not exact", validate_scenario(scenario))
scenario = copy.deepcopy(self.by_id["declined-apply"])
scenario["observed"]["ledger"].append(copy.deepcopy(scenario["observed"]["ledger"][0]))
self.assertIn("declined proposal ledger is not exact", validate_scenario(scenario))
scenario = copy.deepcopy(self.by_id["no-item-existing-owner"])
scenario["observed"]["ledger"].append(copy.deepcopy(scenario["observed"]["ledger"][0]))
self.assertIn(
"no-item ledger does not exactly match classified existing nodes",
validate_scenario(scenario),
)
scenario = copy.deepcopy(self.by_id["partially-materialized-tree"])
scenario["observed"]["ledger"].append(
{"ref": "ghost", "status": "failed", "actualId": None}
)
self.assertIn(
"proposal-only ledger does not exactly match reused nodes",
validate_scenario(scenario),
)
def test_failed_or_skipped_calls_cannot_have_actual_ids(self) -> None:
scenario = copy.deepcopy(self.by_id["partial-failure-recovery"])
failed_call = next(
call for call in scenario["observed"]["writeCalls"] if call["status"] == "failed"
)
failed_row = next(
row for row in scenario["observed"]["ledger"] if row["status"] == "failed"
)
failed_call["actualId"] = "fixture-duplicate-risk"
failed_row["actualId"] = "fixture-duplicate-risk"
self.assertIn(
"failed child-2 call unexpectedly has an actual ID",
validate_scenario(scenario),
)
def test_existing_tree_identity_topology_and_reuse_ledger_are_exact(self) -> None:
scenario = copy.deepcopy(self.by_id["existing-duplicate-tree"])
scenario["expected"]["relationships"] = []
self.assertIn(
"proposed reuse topology does not match authoritative source nodes",
validate_scenario(scenario),
)
scenario = copy.deepcopy(self.by_id["partially-materialized-tree"])
scenario["expected"]["items"][0]["existingId"] = "unrelated-owner"
scenario["observed"]["ledger"] = []
errors = validate_scenario(scenario)
self.assertIn("proposed existing IDs do not exactly match authoritative source nodes", errors)
self.assertIn("reuse ledger does not exactly match proposed existing nodes", errors)
def test_decline_cannot_record_a_write(self) -> None:
scenario = copy.deepcopy(self.by_id["declined-apply"])
scenario["observed"]["writeCalls"].append({"action": "create", "ref": "owner"})
self.assertIn("declined proposal observed writes", validate_scenario(scenario))
def test_mechanical_sequence_has_no_blocking_edges(self) -> None:
scenario = self.by_id["mechanical-dependency-sequence"]
self.assertEqual([], validate_scenario(scenario))
self.assertFalse(
any(
relationship["kind"] == "blocking"
for relationship in scenario["expected"]["relationships"]
)
)
def test_blockers_need_declared_refs_and_acceptance_dependencies(self) -> None:
scenario = copy.deepcopy(self.by_id["bounded-epic-conversion"])
blocker = next(
relationship
for relationship in scenario["expected"]["relationships"]
if relationship["kind"] == "blocking"
)
blocker["to"] = "bogus-child"
blocker["rationale"] = "Do first because this is the planned work sequence."
blocker["acceptanceCondition"] = ""
errors = validate_scenario(scenario)
self.assertIn("relationship references an undeclared proposal ref", errors)
self.assertIn("blocking relationship lacks an acceptance condition", errors)
self.assertIn("blocking relationship represents plan-step sequencing", errors)
self.assertIn("logical blocker writes do not exactly match proposed blocking relationships", errors)
def test_blocker_endpoints_must_match_source_acceptance_evidence(self) -> None:
scenario = copy.deepcopy(self.by_id["bounded-epic-conversion"])
blocker = next(
relationship
for relationship in scenario["expected"]["relationships"]
if relationship["kind"] == "blocking"
)
blocker.update(
{
"from": "child-3",
"to": "child-2",
"rationale": "Child 3 cannot satisfy acceptance until child 2 exists.",
"acceptanceCondition": "Child 2 is available.",
}
)
blocker_write = next(
write
for write in scenario["expected"]["logicalWrites"]
if write["action"] == "add-blocker"
)
blocker_write.update({"dependent": "child-3", "prerequisite": "child-2"})
self.assertIn(
"blocking relationships do not match source acceptance dependencies",
validate_scenario(scenario),
)
if __name__ == "__main__":
unittest.main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |