From 973efc4ea428051d16743f156ea6ed486a221eb6 Mon Sep 17 00:00:00 2001 From: memtomem <118508877+memtomem@users.noreply.github.com> Date: Sun, 15 Nov 2026 09:27:30 +0900 Subject: [PATCH] Freeze released work-boards and read them with the current readers (#271) The first half of the Board family of the persisted-contracts D rows. tests/fixtures/persisted/board// holds the board databases v0.1.2, v0.2.0 and v0.3.0 wrote with their own CLIs: board add, run (a fake codex whose behaviour each run sets), update, import-review- candidates, decide and, from v0.2.0, compact. - lifecycle: gate evidence passing (route) and failing (pipeline; route drops a rejected gate report), the agent's done and review blocks with handoff and outputs, an agent failure, a killed claim reclaimed by the release's next run, manual evidence, sign-off, a refused bare done, a human block, an annotate, human-required set and cleared, dependencies on a done, a planned and a missing item, an imported review candidate, and decisions global, scoped and superseded; - running: a run SIGKILLed while its agent works, with its WAL; - crash-blocked: a SIGINT and an orchestration crash (a .pth hook loaded for the run only raises inside Supervisor.run); - compacted (v0.2.0, v0.3.0): partly compacted, so one item's claims and reclaim live only in the rollups and another's are split between the rollups and the live audit. The generator fails unless every shape the tests read is present, and refuses a cell holding the box path, home or hostname, so nothing is rebound. After copying each database it has the release's own interpreter read a scratch copy (Board.get, list, transitions, active_decisions, _row_to_decision on every row, stats at a fresh and an aged clock and on both sides of an item's aging cutoff): those reads are the expected values. The test works on copies and reads: - HEAD's first open: the added columns and tables, every released cell kept, a second open a no-op, the files 0600; - Board.get, list (filtered too) and transitions field by field against the release's reads and against the raw cells; - board list and board show, both against the release's reads through the renderers and line by line from the release's values alone; - active_decisions, _row_to_decision (retired rows included), board decisions, project_lessons (no released decision is a lesson), stats and board stats; - the human path on released rows: done counting stored evidence or refused without it, sign-off, clear-human-required, an annotate keeping a released lease, supersede in and out of scope, a re-import skipped, and refused when the stored provenance differs in any checked part. No source under src/ changes; no current reader misread a released row. 48 injected one-line regressions in board.py each fail the test. Co-Authored-By: Claude Opus 5.5 --- docs/architecture/persisted-contracts.md | 2 +- tests/fixtures/persisted/board/freeze.py | 636 ++++++ .../persisted/board/v0.1.2/bindings.json | 1557 +++++++++++++ .../board/v0.1.2/crash-blocked/board.db | Bin 0 -> 69632 bytes .../persisted/board/v0.1.2/lifecycle/board.db | Bin 0 -> 77824 bytes .../persisted/board/v0.1.2/running/board.db | Bin 0 -> 69632 bytes .../board/v0.1.2/running/board.db-shm | Bin 0 -> 32768 bytes .../board/v0.1.2/running/board.db-wal | Bin 0 -> 37112 bytes .../persisted/board/v0.2.0/bindings.json | 2015 +++++++++++++++++ .../persisted/board/v0.2.0/compacted/board.db | Bin 0 -> 98304 bytes .../board/v0.2.0/compacted/board.db.gc-lock | 0 .../board/v0.2.0/crash-blocked/board.db | Bin 0 -> 98304 bytes .../persisted/board/v0.2.0/lifecycle/board.db | Bin 0 -> 106496 bytes .../board/v0.2.0/lifecycle/board.db.gc-lock | 0 .../persisted/board/v0.2.0/running/board.db | Bin 0 -> 98304 bytes .../board/v0.2.0/running/board.db-shm | Bin 0 -> 32768 bytes .../board/v0.2.0/running/board.db-wal | Bin 0 -> 45352 bytes .../persisted/board/v0.3.0/bindings.json | 2015 +++++++++++++++++ .../persisted/board/v0.3.0/compacted/board.db | Bin 0 -> 102400 bytes .../board/v0.3.0/compacted/board.db.gc-lock | 0 .../board/v0.3.0/crash-blocked/board.db | Bin 0 -> 102400 bytes .../persisted/board/v0.3.0/lifecycle/board.db | Bin 0 -> 110592 bytes .../board/v0.3.0/lifecycle/board.db.gc-lock | 0 .../persisted/board/v0.3.0/running/board.db | Bin 0 -> 102400 bytes .../board/v0.3.0/running/board.db-shm | Bin 0 -> 32768 bytes .../board/v0.3.0/running/board.db-wal | Bin 0 -> 49472 bytes tests/test_frozen_board.py | 786 +++++++ 27 files changed, 7010 insertions(+), 1 deletion(-) create mode 100644 tests/fixtures/persisted/board/freeze.py create mode 100644 tests/fixtures/persisted/board/v0.1.2/bindings.json create mode 100644 tests/fixtures/persisted/board/v0.1.2/crash-blocked/board.db create mode 100644 tests/fixtures/persisted/board/v0.1.2/lifecycle/board.db create mode 100644 tests/fixtures/persisted/board/v0.1.2/running/board.db create mode 100644 tests/fixtures/persisted/board/v0.1.2/running/board.db-shm create mode 100644 tests/fixtures/persisted/board/v0.1.2/running/board.db-wal create mode 100644 tests/fixtures/persisted/board/v0.2.0/bindings.json create mode 100644 tests/fixtures/persisted/board/v0.2.0/compacted/board.db create mode 100644 tests/fixtures/persisted/board/v0.2.0/compacted/board.db.gc-lock create mode 100644 tests/fixtures/persisted/board/v0.2.0/crash-blocked/board.db create mode 100644 tests/fixtures/persisted/board/v0.2.0/lifecycle/board.db create mode 100644 tests/fixtures/persisted/board/v0.2.0/lifecycle/board.db.gc-lock create mode 100644 tests/fixtures/persisted/board/v0.2.0/running/board.db create mode 100644 tests/fixtures/persisted/board/v0.2.0/running/board.db-shm create mode 100644 tests/fixtures/persisted/board/v0.2.0/running/board.db-wal create mode 100644 tests/fixtures/persisted/board/v0.3.0/bindings.json create mode 100644 tests/fixtures/persisted/board/v0.3.0/compacted/board.db create mode 100644 tests/fixtures/persisted/board/v0.3.0/compacted/board.db.gc-lock create mode 100644 tests/fixtures/persisted/board/v0.3.0/crash-blocked/board.db create mode 100644 tests/fixtures/persisted/board/v0.3.0/lifecycle/board.db create mode 100644 tests/fixtures/persisted/board/v0.3.0/lifecycle/board.db.gc-lock create mode 100644 tests/fixtures/persisted/board/v0.3.0/running/board.db create mode 100644 tests/fixtures/persisted/board/v0.3.0/running/board.db-shm create mode 100644 tests/fixtures/persisted/board/v0.3.0/running/board.db-wal create mode 100644 tests/test_frozen_board.py diff --git a/docs/architecture/persisted-contracts.md b/docs/architecture/persisted-contracts.md index 2c97ed9..2667083 100644 --- a/docs/architecture/persisted-contracts.md +++ b/docs/architecture/persisted-contracts.md @@ -55,7 +55,7 @@ A golden over the current writer does not protect these. A reader can stop accep | Rooms | the room database (`rooms.sqlite3`, with the WAL a killed process leaves): rooms, rounds, candidates, members, workspaces, events, `sessions_json`, `selection_json` v1, `provenance_json` v1/v2, `conversation_json` v1; candidate `manifest.json`, patch and output; room-bound run artifacts. No release wrote `conversation_json` v2 or judgment rows | `room list` / `rounds` / `show` / `candidates` / `diff` / `compare` / `export`, `select`, `apply`, `judge`, `recover`, `close`, `prune` `RoomStore.member_sessions` (and through these `RoomCandidateStore.load`, `_parse_sessions_json`, `selection_record_status`, `room_outcome_status`, `round_provenance_status`, `round_conversation_status`); the standalone `apply` / `recover` refusal and skip for room-bound artifacts; a HEAD `room round` on a released room (`branch-from` resuming the released sessions on the released base patch, `fresh`, a first round on a draft, and the `continue-own` refusal when the released workspaces are gone); `room attach` over the released member log paths (tmux faked); the `apply --verify` settings notices; raw export (`--include` preview and confirm); the TUI Rooms tab's readers and pure renders (`build_room_evidence`, `render_room`, `render_round_table`, and the Diff, Output and Details views), not the Textual app | `test_frozen_rooms.py` (v0.1.2, v0.2.0, v0.3.0) | | Workflows | the workflow database (`workflows.db`): rows with `spec_json`, manifest `schema_version` 3 with `calls_used`, events, and from v0.3.0 the lineage columns and `file`/`revision` origins; per workflow `spec.json`, planner output, node bundles (`result.json`, `winner.patch`, `commit.json` v3) and stream logs; workflow-origin run artifacts, approved or not, with `plan.final_agent` from v0.3.0. No release wrote manifest v1 or v2 (both normalize to v3 before the insert); those readers stay covered by `test_workflow_durable.py::test_marked_v1_migration_preserves_exact_count_and_control_fields` and `test_workflow.py::test_a_workflow_whose_call_accounting_is_ambiguous_is_refused` | `workflow list` / `show` (`--prompts`) / `status` / `logs` / `lineage` / `export` / `cancel` / `prune`, a dead release-written lease recovered by `show` and `status`, `WorkflowStore.events` and `read_node_bundle`; for the final artifact `diff`, `runs show`, `apply` (approved, after a prune, approval healed from the database, refused for a workflow that never completed, `no_changes`), the standalone `recover` skip. A final artifact naming another run, and an unreadable store: `test_cli.py::test_apply_refuses_an_artifact_the_named_workflow_did_not_finalize` and `test_apply_guard_fails_closed_when_the_workflow_store_cannot_be_read`. HEAD execution (`WorkflowCoordinator.run`, what the job worker calls): `run` of released planned, created and revised rows (accounting, stored prompts, dependency output); `resume` of released crashes and failures against the stored deadline (expired: fails before dispatch; before it: the completed dependency's bundle is reused and the unfinished node's attempt refunded, a published final artifact is reused and approved without backfilling `final_agent`, an exhausted node dispatches nothing), refused from a final or unstarted state and while the owner lives, with the released execution history and events kept; `workflow revise` (a v0.2.0 parent gains a lineage); the launch's team peek and state check; `apply --verify` narrowing (v0.2.0: the gate's list only, with a notice; also after a prune); control plans enabled refuse a released workflow planned without one. Written later by the same releases (`freeze.py --part 2b`, `bindings-2b.json`): a node bundle saved just before the crash, reclaimed on resume through `read_node_result` / `read_node_bundle` with its usage added once (`_record_usage`), and re-run when its patch, its commit record or its digest disagrees; control-plan workflows, whose released `control-plan.json` is the control preflight's request, whose binding and validation topology refuse a changed configuration, and whose stored limits and node timeouts bound a run with control plans on, off, or Toolgraph off (`_execution_limits`), plus `show`, `read_control_plan`, `conversations show` and `apply` of a completed one; an interrupted apply of a final artifact, classified by `recover` (completed, not applied, manual recovery; `_bound_receipt`) without touching its approval or the workflow row. Not covered: the TUI's `_read_artifact_result`; no reader revalidates a released execution's `control-preflight.json` | `test_frozen_workflows.py` (v0.2.0, v0.3.0) | | Sessions and project | isolated-session documents in every state a release leaves (open, checkpointed, closed, and from injected exits creating, closing, recovery_required) and their checkpoint run artifacts; the project marker `.syncmill/project.json` and the `syncmill.toml` that `init` writes | `session isolated-list` (`IsolatedSessionStore.list`: live, source staleness in the stored fingerprint's version), `IsolatedSessionStore.load` path binding (repository, workspace run root, worktree, derived tmux name) through `attach-isolated` (state, liveness, pane cwd), `checkpoint` (a missing worktree) and `close` (each state, a missing workspace), `tui_collaboration.render_session`; for the checkpoint artifact `runs list` / `show`, `diff`, `conversations show` / `list` / `close`, `continue` (refused), `recover` (skipped), `apply` and `validate_applicable`, `discard`, `prune` (pending kept), the TUI `render_artifact` / `_read_artifact_result`; `project_id` with the marker untracked, tracked or symlinked, `load_project_config` of the released config, `initialize_project` falling back to the marker. Not covered: a successful checkpoint or worktree cleanup (a release-written workspace is not relocatable) | `test_frozen_sessions.py` (v0.1.2, v0.2.0, v0.3.0) | -| Board | item rows and their evidence and inputs, decisions | `_row_to_item`, `_load_evidence`, `_row_to_decision` | not yet | +| Board | the board database (`board.db`, with the WAL a killed run leaves): items in every state a release's `board add` / `run` / `update` / `import-review-candidates` leave them (gate evidence passing and failing, the agent's `done` and `review` blocks with handoff and outputs, an agent failure, a killed and a reclaimed claim, a SIGINT and an orchestration crash, manual evidence and sign-off, dependencies including a missing one, imported review candidates), their transitions, decisions including a superseded one, the run ledger, and from v0.2.0 the compaction rollups and counters (partly compacted: a count needs both the live audit and the rollups). No release wrote the lesson columns (`project_id`, `provenance_json`, `source_key`); `test_lessons.py::test_an_old_board_gains_the_lesson_columns` and `::test_a_damaged_provenance_reads_as_not_recorded` cover those readers, and the mixed-project tests there the project filter. Every release writes a claim's ledger row in the claim's transaction, so the ledger backfill's positive branch stays covered by the synthetic tests in `test_board.py`; no release writer produces damaged JSON or a malformed evidence entry either | HEAD's first open (columns and tables added, every released cell kept, a second open a no-op), `Board.get` / `list` / `transitions` (`_row_to_item`, `_load_list`, `_load_evidence`) compared field by field with what the release's own interpreter read from the same database and with the raw cells, `board list` / `show`, `active_decisions` and `_row_to_decision` on every row (retired ones included), `board decisions`, `project_lessons` (empty: no released decision is a lesson), `stats` at fixed clocks including both sides of the aging cutoff, and `board stats` at a fresh and an aged clock; the human path on released rows: `update --state done` counting stored evidence or refused without it, `--sign-off`, `--clear-human-required`, an annotate keeping a released lease, `decide --supersedes` in and out of scope, a re-import skipped, and refused when the stored provenance differs. Not covered: HEAD `board run` and GC on a released board, `board compact` of released history, `renew_claim` of a released lease, the gateway, dashboard and TUI board readers (#271 Board-2); the memory a released board run wrote (outside `board.db`) | `test_frozen_board.py` (v0.1.2, v0.2.0, v0.3.0) | | Memory backends | Mem0 and LangGraph stored payloads | the backends' read paths | not yet | | TUI jobs | job documents, `schema_version` 1 and 2 | `JobStore.list_jobs` | not yet | | Run envelope | `envelope.json` | `contracts/run-envelope.schema.json`, `report list` / `report show` | not yet | diff --git a/tests/fixtures/persisted/board/freeze.py b/tests/fixtures/persisted/board/freeze.py new file mode 100644 index 0000000..5023dde --- /dev/null +++ b/tests/fixtures/persisted/board/freeze.py @@ -0,0 +1,636 @@ +"""Produce the frozen work-board databases under this directory (#271). + +Run once per release, with THAT release's interpreter and source, never the +current one. The output directory must not exist; frozen fixtures are never +regenerated. + + git worktree add --detach /tmp/wt-v0.3.0 v0.3.0 + (cd /tmp/wt-v0.3.0 && uv sync --frozen --no-dev) + python tests/fixtures/persisted/board/freeze.py \\ + --release-root /tmp/wt-v0.3.0 --out tests/fixtures/persisted/board/v0.3.0 + +Each scenario is one board database. The released CLI makes every row: +`board add`, `board run` (with a fake `codex` whose behaviour each run sets), +`board update`, `board import-review-candidates`, `board decide` and, from +v0.2.0, `board compact`. Three states need a process death no CLI exposes: +- a run SIGKILLed while its agent works (a live lease, and the WAL it leaves); +- a run interrupted with SIGINT (the release's cancel path); +- a run whose orchestration raises, from a `.pth` hook this script puts in the + release venv for the run and removes afterwards. + +Generation fails unless every property the tests rely on is present (see +`_require`), so a release that writes something else cannot silently narrow +the coverage. The database is copied byte for byte as soon as its scenario +finishes. Only then does the release's own interpreter read a scratch copy and +record what it makes of every row (`Board.get`, `transitions`, +`active_decisions`, the decision rows and `stats` at two fixed clocks): that is +the expected interpretation the tests hold HEAD's readers to. +""" + +from __future__ import annotations + +import argparse +import json +import os +import shutil +import signal +import socket +import sqlite3 +import subprocess +import sys +import tempfile +import time +from pathlib import Path + +TREE = {"calc.py": "def add(a, b):\n return a - b\n"} +GATE = ["python -c \"from calc import add; assert add(2, 3) == 5\""] +MISSING_DEP = "00000000-0000-4000-8000-000000000000" +STALL_SECONDS = 3600 + +# FAKE_PLAN = {"do": fix | wrong | none | fail | hang, "block": {...} | absent}. +# fix makes the gate pass, wrong and none make it fail, fail exits 1, hang waits +# to be killed. A "block" is appended to the reply as a syncmill-board block. +FAKE_AGENT = r''' +import json, os, sys, time +from pathlib import Path +args = sys.argv[1:] +if args[:2] == ["login", "status"] or args[:1] in (["--version"], ["--help"]): + print("codex (fake) - logged in"); sys.exit(0) +plan = json.loads(os.environ.get("FAKE_PLAN") or "{}") +do = plan.get("do", "fix") +if do == "hang": + marker = Path(os.environ["FAKE_STARTED"]) / "codex" + marker.with_suffix(".tmp").write_text(str(os.getpid())) + os.replace(marker.with_suffix(".tmp"), marker) + time.sleep(120); sys.exit(1) +if do == "fail": + sys.stderr.write("codex (fake): refused\n"); sys.exit(1) +body = {"fix": "a + b", "wrong": "a * b"}.get(do) +if body: + Path("calc.py").write_text("def add(a, b):\n return " + body + "\n", encoding="utf-8") +message = "codex (fake) " + do + "." +if plan.get("block"): + message += "\n```syncmill-board\n" + json.dumps(plan["block"]) + "\n```\n" +for event in [ + {"type": "thread.started", "thread_id": "fake-codex-thread"}, + {"type": "item.completed", "item": {"type": "agent_message", "text": message}}, + {"type": "turn.completed", "usage": {"input_tokens": 1, "output_tokens": 1}}, +]: + print(json.dumps(event)) +''' + +# Loaded at interpreter start by the .pth below, in every process of the +# release venv. With HOME/crash-at present the orchestration raises inside +# run_item's guard (Supervisor.run), the way a bug in a strategy would. +HOOK_MODULE = "_syncmill_freeze_board_hook" +CRASH_HOOK = '''\ +import os +from pathlib import Path + + +def _install(): + flag = Path(os.environ.get("HOME", "/nonexistent")) / "crash-at" + if not flag.is_file(): + return + from syncmill.supervisor import Supervisor + + def run(self, *args, **kwargs): + raise RuntimeError("frozen: injected orchestration failure") + Supervisor.run = run + + +_install() +''' + +# Runs inside the RELEASED interpreter on a scratch copy: what the release +# itself reads from every row. argv: db, frozen_at, decision goals (JSON list), +# stall seconds, and the item whose aging boundary is probed ("" for none). +RELEASE_READ = '''\ +import dataclasses, enum, json, math, sqlite3, sys +from syncmill.board import Board, _row_to_decision +db, frozen_at, goals = sys.argv[1], float(sys.argv[2]), json.loads(sys.argv[3]) +stall, boundary_item = int(sys.argv[4]), sys.argv[5] + + +def plain(value): + if isinstance(value, enum.Enum): + return value.value + if dataclasses.is_dataclass(value): + return {f.name: plain(getattr(value, f.name)) for f in dataclasses.fields(value)} + if isinstance(value, (list, tuple)): + return [plain(v) for v in value] + if isinstance(value, dict): + return {k: plain(v) for k, v in value.items()} + return value + + +board = Board(db, now=lambda: frozen_at, stall_seconds=stall) +items = board.list() +conn = sqlite3.connect(db) +conn.row_factory = sqlite3.Row +read = { + "items": {it.id: plain(board.get(it.id)) for it in items}, + "order": [it.id for it in items], + "transitions": {it.id: board.transitions(it.id) for it in items}, + "active_decisions": { + "*": [plain(d) for d in board.active_decisions()], + **{g: [plain(d) for d in board.active_decisions(goal=g)] for g in goals}, + }, + "decision_rows": [dict(r) for r in conn.execute("SELECT * FROM decisions ORDER BY rowid")], + # Every decision row through the release's own mapper, retired ones too: + # no listing returns a superseded decision, so its superseded_by and + # superseded_at reach a reader only through the mapper itself. + "decisions_mapped": [ + plain(_row_to_decision(r)) + for r in conn.execute("SELECT * FROM decisions ORDER BY rowid") + ], + "aggregates": { + table: [dict(r) for r in conn.execute(f"SELECT * FROM {table} ORDER BY rowid")] + for (table,) in conn.execute( + "SELECT name FROM sqlite_master WHERE type='table' " + "AND name IN ('transition_rollups', 'transition_counters') ORDER BY name" + ).fetchall() + }, + "stats": { + "fresh": plain(board.stats(now=frozen_at)), + "aged": plain(board.stats(now=frozen_at + stall + 1)), + }, +} +if boundary_item: + # The clocks around an item's aging boundary (stats ages an item once + # updated_at <= now - stall): the last one that does not age it, the first + # one that does, and the one after. + updated = board.get(boundary_item).updated_at + first = updated + stall + while first - stall < updated: + first = math.nextafter(first, math.inf) + while math.nextafter(first, -math.inf) - stall >= updated: + first = math.nextafter(first, -math.inf) + times = {"before": math.nextafter(first, -math.inf), "at": first, + "after": math.nextafter(first, math.inf)} + read["boundary"] = { + "item": boundary_item, + "times": times, + "stats": {k: plain(board.stats(now=t)) for k, t in times.items()}, + } +conn.close() +board.close() +print(json.dumps(read, ensure_ascii=False, sort_keys=True)) +''' + +GIT_ENV = { + "GIT_AUTHOR_NAME": "frozen", "GIT_AUTHOR_EMAIL": "frozen@example.invalid", + "GIT_COMMITTER_NAME": "frozen", "GIT_COMMITTER_EMAIL": "frozen@example.invalid", + "GIT_AUTHOR_DATE": "2026-01-01T00:00:00Z", "GIT_COMMITTER_DATE": "2026-01-01T00:00:00Z", +} + + +def _site_packages(python: Path) -> Path: + return Path(subprocess.run( + [str(python), "-c", "import sysconfig; print(sysconfig.get_paths()['purelib'])"], + check=True, capture_output=True, text=True, + ).stdout.strip()) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--release-root", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + release = args.release_root.resolve() + out = args.out.resolve() + if out.exists(): + sys.exit(f"{out} exists; frozen fixtures are never regenerated") + python = release / ".venv" / "bin" / "python" + syncmill = release / ".venv" / "bin" / "syncmill" + version = subprocess.run( + [str(python), "-c", "import importlib.metadata as m; print(m.version('syncmill'))"], + check=True, capture_output=True, text=True, + ).stdout.strip() + has_compact = version != "0.1.2" + site = _site_packages(python) + hook_files = [site / f"{HOOK_MODULE}.py", site / f"zz{HOOK_MODULE}.pth"] + if any(p.exists() for p in hook_files): + sys.exit(f"hook files already present in {site}; remove them first") + try: + hook_files[0].write_text(CRASH_HOOK, encoding="utf-8") + hook_files[1].write_text(f"import {HOOK_MODULE}\n", encoding="utf-8") + _generate(release, out, python, syncmill, version, has_compact) + finally: + for p in hook_files: + p.unlink(missing_ok=True) + + +def _generate(release: Path, out: Path, python: Path, syncmill: Path, + version: str, has_compact: bool) -> None: + with tempfile.TemporaryDirectory() as tmp: + box = Path(tmp).resolve() + repo, home, state, fakebin, started = ( + box / n for n in ("repo", "home", "state", "fakebin", "started") + ) + for folder in (repo, home, state, fakebin, started): + folder.mkdir() + (fakebin / "codex").write_text(f"#!{sys.executable}\n" + FAKE_AGENT, encoding="utf-8") + (fakebin / "codex").chmod(0o755) + (fakebin / "python").symlink_to(sys.executable) + base_env = { + "HOME": str(home), + "PATH": os.pathsep.join([str(fakebin), "/usr/bin", "/bin"]), + "TMPDIR": str(box), + "GIT_CONFIG_NOSYSTEM": "1", + "PYTHONDONTWRITEBYTECODE": "1", + "FAKE_STARTED": str(started), + "SYNCMILL_AGENT_PRIORITY": json.dumps(["codex"]), + "SYNCMILL_CLAUDE__ENABLED": "false", + "SYNCMILL_BOARD__ENABLED": "true", + "SYNCMILL_BOARD__STALL_SECONDS": str(STALL_SECONDS), + "SYNCMILL_GATE__COMMANDS": json.dumps(GATE), + "SYNCMILL_RUNS__ROOT": str(state / "runs"), + "SYNCMILL_WORKSPACE__ROOT": str(state / "workspaces"), + "SYNCMILL_MEMORY__DB_PATH": str(state / "memory" / "memtomem.db"), + "SYNCMILL_MEMORY__MEMORY_DIR": str(state / "memory" / "files"), + "SYNCMILL_BREAKER__STATE_PATH": str(state / "breaker.json"), + "SYNCMILL_TUI__STATE_DIR": str(state / "tui"), + "SYNCMILL_PROJECT__ID": "frozen-board", + **GIT_ENV, + } + + def git(*argv: str) -> None: + subprocess.run(["git", *argv], cwd=repo, env=base_env, check=True, + capture_output=True) + + git("init", "-q", "-b", "main") + for name, text in TREE.items(): + (repo / name).write_text(text, encoding="utf-8") + git("add", "-A") + git("commit", "-q", "-m", "frozen tree") + + out.mkdir(parents=True) + report = release / "tests" / "fixtures" / "tracegraph" / "v1.json" + bindings: dict = { + "release": version, + "box_root": str(box), + "stall_seconds": STALL_SECONDS, + "missing_dependency": MISSING_DEP, + "tracegraph_report": "tests/fixtures/tracegraph/v1.json", + "scenarios": {}, + } + + class Scenario: + def __init__(self, name: str): + self.name = name + self.dir = state / name + self.dir.mkdir() + self.env = {**base_env, "SYNCMILL_BOARD__DB_PATH": str(self.dir / "board.db")} + self.items: dict[str, str] = {} + self.decisions: dict[str, str] = {} + + def sm(self, *argv: str, ok: bool = True, plan: dict | None = None, + env: dict | None = None) -> str: + done = subprocess.run( + [str(syncmill), *argv], cwd=repo, + env={**self.env, "FAKE_PLAN": json.dumps(plan or {}), **(env or {})}, + capture_output=True, text=True, + ) + if ok and done.returncode != 0: + sys.exit(f"{self.name}: {argv}: {done.stdout}{done.stderr}") + if not ok and done.returncode == 0: + sys.exit(f"{self.name}: {argv} was expected to fail: {done.stdout}") + return done.stdout + + def add(self, role: str, task: str, *flags: str) -> str: + line = self.sm("board", "add", task, *flags) + self.items[role] = line.split("added item ")[1].split()[0] + return self.items[role] + + def run(self, role: str, plan: dict, *flags: str, ok: bool = True, + env: dict | None = None) -> None: + self.sm("board", "run", "--id", self.items[role], *flags, + ok=ok, plan=plan, env=env) + + def update(self, role: str, *flags: str, ok: bool = True) -> None: + self.sm("board", "update", self.items[role], *flags, ok=ok) + + def decide(self, role: str, text: str, *flags: str) -> None: + line = self.sm("board", "decide", text, *flags) + self.decisions[role] = line.split("recorded decision ")[1].split()[0] + + def hang(self, role: str): + """Start a run whose agent hangs; return it once the agent is up.""" + for p in started.iterdir(): + p.unlink() + proc = subprocess.Popen( + [str(syncmill), "board", "run", "--id", self.items[role]], + cwd=repo, env={**self.env, "FAKE_PLAN": json.dumps({"do": "hang"})}, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, + start_new_session=True, + ) + deadline = time.monotonic() + 60 + while not (started / "codex").exists(): + if proc.poll() is not None or time.monotonic() > deadline: + sys.exit(f"{self.name}: hanging agent never started: " + f"{proc.communicate()[0] if proc.poll() is not None else ''}") + time.sleep(0.1) + return proc, int((started / "codex").read_text()) + + def kill(self, role: str) -> None: + proc, agent = self.hang(role) + os.killpg(proc.pid, signal.SIGKILL) + proc.wait() + _kill_quietly(agent) + + def interrupt(self, role: str) -> None: + proc, agent = self.hang(role) + proc.send_signal(signal.SIGINT) + try: + proc.wait(timeout=60) + except subprocess.TimeoutExpired: + os.killpg(proc.pid, signal.SIGKILL) + sys.exit(f"{self.name}: SIGINT did not end the run") + _kill_quietly(agent) + + def crash(self, role: str) -> None: + flag = home / "crash-at" + flag.write_text("run", encoding="utf-8") + try: + self.run(role, {"do": "fix"}, ok=False) + finally: + flag.unlink() + + def reclaim(self, role: str) -> None: + """Kill a claim, then let the release's next run reclaim and finish it.""" + self.kill(role) + time.sleep(2) + self.run(role, {"do": "fix"}, + env={"SYNCMILL_BOARD__LEASE_TIMEOUT_SECONDS": "1"}) + + def freeze(sc: Scenario, *, killed: bool, goals: list[str], + boundary: str = "") -> dict: + wal = sorted(p.name for p in sc.dir.glob("*-wal")) + if bool(wal) != killed: + sys.exit(f"{sc.name}: expected {'a' if killed else 'no'} WAL, found {wal}") + shutil.copytree(sc.dir, out / sc.name) + read = release_read(sc, goals, sc.items.get(boundary, "")) + # Rows no `board add` named (the imported review candidates) get a + # role from their position in the release's own FIFO listing. + unnamed = [i for i in read["order"] if i not in sc.items.values()] + for n, item_id in enumerate(unnamed, 1): + sc.items[f"imported-{n}"] = item_id + entry = { + "items": sc.items, + "decisions": sc.decisions, + "frozen_at": read.pop("frozen_at"), + "files": sorted(p.name for p in (out / sc.name).iterdir()), + "release_read": read, + } + bindings["scenarios"][sc.name] = entry + return entry + + def release_read(sc: Scenario, goals: list[str], boundary_item: str = "") -> dict: + # A scratch copy with its sidecars, read with a normal connection: + # rows still in a killed process's WAL are seen, and neither the + # release nor this script ever opens the frozen files. + scratch = box / "read" / sc.name + shutil.rmtree(scratch, ignore_errors=True) + shutil.copytree(sc.dir, scratch) + db = scratch / "board.db" + _no_machine_values(db, box, home) + with sqlite3.connect(db) as conn: + frozen_at = conn.execute( + "SELECT MAX(m) FROM (SELECT MAX(updated_at) AS m FROM work_items " + "UNION ALL SELECT MAX(at) FROM transitions " + "UNION ALL SELECT MAX(created_at) FROM decisions)" + ).fetchone()[0] + conn.close() + done = subprocess.run( + [str(python), "-c", RELEASE_READ, str(db), repr(frozen_at), + json.dumps(goals), str(STALL_SECONDS), boundary_item], + env={**base_env, "SYNCMILL_BOARD__DB_PATH": str(db)}, + capture_output=True, text=True, + ) + if done.returncode != 0: + sys.exit(f"{sc.name}: release read failed: {done.stderr}") + read = json.loads(done.stdout) + read["frozen_at"] = frozen_at + return read + + # ── lifecycle: every row shape the released CLI writes ─────────── + sc = Scenario("lifecycle") + sc.add("passed", "fix add") + sc.run("passed", {"do": "fix"}) + sc.add("verified", "fix add and finish", "--goal", "backend") + sc.run("verified", {"do": "fix", "block": {"state": "done"}}) + sc.add("handed-off", "덧셈을 고친다", "--goal", "backend") + sc.run("handed-off", {"do": "fix", "block": { + "state": "review", "handoff": "검토: 부호를 확인할 것", + "outputs": ["notes/plan.md"]}}) + sc.add("route-gate-failed", "fix add badly") + sc.run("route-gate-failed", {"do": "wrong"}, ok=False) + sc.add("pipeline-gate-failed", "fix add badly in a pipeline") + sc.run("pipeline-gate-failed", {"do": "wrong"}, "--strategy", "pipeline", ok=False) + sc.add("agent-failed", "ask a refusing agent") + sc.run("agent-failed", {"do": "fail"}, ok=False) + sc.add("reclaimed", "fix add after a crash") + sc.reclaim("reclaimed") + sc.add("evidence-done", "verified by CI") + sc.run("evidence-done", {"do": "fix"}) + sc.update("evidence-done", "--state", "done", "--evidence", "CI ✓ run 42 — grün") + sc.add("signed-off", "verified by a human") + sc.run("signed-off", {"do": "fix"}) + sc.update("signed-off", "--state", "done", "--sign-off") + sc.add("bare-done-refused", "no verification yet") + sc.update("bare-done-refused", "--state", "done", ok=False) + sc.add("human-blocked", "waits on ops") + sc.update("human-blocked", "--state", "blocked", "--note", "waiting on ops") + sc.add("annotated", "carries a reference") + sc.update("annotated", "--evidence", "https://example.invalid/log/7") + sc.add("human-required", "needs a person", "--human-required") + sc.add("human-cleared", "needed a person", "--human-required") + sc.update("human-cleared", "--clear-human-required") + sc.add("needs-done", "after the verified item", "--depends-on", sc.items["verified"]) + sc.add("needs-planned", "after a planned item", "--depends-on", sc.items["annotated"]) + sc.add("needs-missing", "after an item that does not exist", "--depends-on", MISSING_DEP) + sc.add("needs-two", "after two items", + "--depends-on", sc.items["verified"], "--depends-on", sc.items["annotated"]) + line = sc.sm("board", "import-review-candidates", str(report), "--goal", "review") + if "imported" not in line: + sys.exit(f"lifecycle: import printed {line!r}") + sc.decide("global", "Use uv for every Python command.") + sc.decide("scoped", "백엔드는 SQLite를 유지한다.", "--scope", "backend") + sc.decide("superseded", "Tabs, not spaces.") + sc.decide("replacement", "Spaces, not tabs.", "--supersedes", sc.decisions["superseded"]) + sc.decide("other-scope", "Ship the docs with the code.", "--scope", "docs") + entry = freeze(sc, killed=False, goals=["backend", "docs", "review", "nothing"], + boundary="human-blocked") + _require_lifecycle(entry) + + # ── running: a run killed while its agent works ────────────────── + sc = Scenario("running") + sc.add("waiting", "still planned") + sc.add("killed", "killed mid-run", "--goal", "backend") + sc.kill("killed") + entry = freeze(sc, killed=True, goals=["backend"]) + _require(entry, "killed", state="running", lease=True) + + # ── crash-blocked: the release's cancel and crash paths ────────── + sc = Scenario("crash-blocked") + sc.add("interrupted", "interrupted by the operator") + sc.interrupt("interrupted") + sc.add("crashed", "orchestration raises") + sc.crash("crashed") + entry = freeze(sc, killed=False, goals=[], boundary="crashed") + _require(entry, "interrupted", state="blocked", human=True, + note="orchestration cancelled by operator (SIGINT)") + _require(entry, "crashed", state="blocked", human=True, + note="orchestration crashed: RuntimeError: frozen: injected orchestration failure") + + # ── compacted: aggregates folded out of a partly trimmed audit ──── + # `rolled` is reclaimed and re-claimed entirely before the cutoff, so + # its two claims and its reclaim live only in the rollups. `mixed` is + # claimed before the cutoff and reclaimed and re-claimed after it, so + # each of its counts needs the live rows AND the rollups. + if has_compact: + sc = Scenario("compacted") + sc.add("rolled", "fix add after a crash") + sc.reclaim("rolled") + sc.add("mixed", "fix add after a later crash") + sc.kill("mixed") + time.sleep(6) + sc.run("mixed", {"do": "fix"}, + env={"SYNCMILL_BOARD__LEASE_TIMEOUT_SECONDS": "1"}) + sc.add("passed", "fix add") + sc.run("passed", {"do": "fix"}) + before = release_read(sc, []) + history = before["transitions"][sc.items["mixed"]] + first_claim = history[1]["at"] + recovery = next(t["at"] for t in history if t["note"] == "stale-claim recovery") + if recovery - first_claim < 4: + sys.exit(f"compacted: no room for a cutoff: {history!r}") + older_than = time.time() - (first_claim + recovery) / 2 + line = sc.sm("board", "compact", "--older-than", f"{older_than:.3f}") + if not line.startswith("Compacted "): + sys.exit(f"compacted: compact printed {line!r}") + entry = freeze(sc, killed=False, goals=[]) + entry["before_compaction"] = before + _require_compacted(entry, before) + + (out / "bindings.json").write_text( + json.dumps(bindings, indent=2, ensure_ascii=False, sort_keys=True) + "\n", + encoding="utf-8", + ) + + +def _kill_quietly(pid: int) -> None: + try: + os.kill(pid, signal.SIGKILL) + except ProcessLookupError: + pass + + +def _no_machine_values(db: Path, box: Path, home: Path) -> None: + needles = {str(box), str(home), socket.gethostname(), os.path.expanduser("~")} + with sqlite3.connect(db) as conn: + for (table,) in conn.execute("SELECT name FROM sqlite_master WHERE type='table'"): + for row in conn.execute(f"SELECT * FROM {table}"): + for cell in row: + if isinstance(cell, str) and any(n and n in cell for n in needles): + sys.exit(f"{db}: {table} holds a machine-bound value: {cell[:200]!r}") + conn.close() + + +def _require(entry: dict, role: str, *, state: str, human: bool | None = None, + lease: bool | None = None, note: str | None = None, + evidence: list | None = None) -> None: + item_id = entry["items"][role] + item = entry["release_read"]["items"][item_id] + history = entry["release_read"]["transitions"][item_id] + problems = [] + if item["state"] != state: + problems.append(f"state {item['state']!r}") + if human is not None and item["human_required"] != human: + problems.append(f"human_required {item['human_required']!r}") + if lease is not None and bool(item["lease_run_id"]) != lease: + problems.append(f"lease {item['lease_run_id']!r}") + if note is not None and history[-1]["note"] != note: + problems.append(f"last note {history[-1]['note']!r}") + if evidence is not None: + got = [(e["kind"], e["passed"]) for e in item["evidence"]] + if got != evidence: + problems.append(f"evidence {got!r}") + if problems: + sys.exit(f"{role}: required property missing: {', '.join(problems)}") + + +def _claims(history: list[dict]) -> int: + return sum(1 for t in history if (t["from_state"], t["to_state"]) == ("planned", "running")) + + +def _require_lifecycle(entry: dict) -> None: + _require(entry, "passed", state="review", evidence=[("gate", True)], + note="agent completed; awaiting review") + _require(entry, "verified", state="done", evidence=[("gate", True)], + note="agent completed; verified") + _require(entry, "handed-off", state="review", evidence=[("gate", True)]) + _require(entry, "route-gate-failed", state="blocked", human=True, evidence=[]) + _require(entry, "pipeline-gate-failed", state="blocked", human=True, + evidence=[("gate", False)]) + _require(entry, "agent-failed", state="blocked", human=True, evidence=[]) + _require(entry, "reclaimed", state="review", evidence=[("gate", True)]) + _require(entry, "evidence-done", state="done", evidence=[("gate", True), ("manual", True)]) + _require(entry, "signed-off", state="done", evidence=[("gate", True), ("human", True)]) + _require(entry, "bare-done-refused", state="planned", evidence=[]) + _require(entry, "human-blocked", state="blocked", note="waiting on ops") + _require(entry, "annotated", state="planned", evidence=[("manual", True)]) + _require(entry, "human-required", state="planned", human=True) + _require(entry, "human-cleared", state="planned", human=False) + read = entry["release_read"] + handed = read["items"][entry["items"]["handed-off"]] + if not handed["handoff"] or "notes/plan.md" not in handed["outputs"]: + sys.exit(f"handed-off: handoff/outputs not recorded: {handed!r}") + reclaimed = read["transitions"][entry["items"]["reclaimed"]] + if _claims(reclaimed) != 2 or not any(t["note"] == "stale-claim recovery" for t in reclaimed): + sys.exit(f"reclaimed: expected two claims and a stale recovery: {reclaimed!r}") + imported = [read["items"][i] for r, i in entry["items"].items() if r.startswith("imported-")] + if not imported or any( + len(i["inputs"]) != 5 or i["state"] != "review" or not i["human_required"] + or [(e["kind"], e["passed"]) for e in i["evidence"]] != [("tracegraph", False)] + for i in imported + ): + sys.exit(f"lifecycle: review candidates not imported as expected: {imported!r}") + active = {d["id"] for d in read["active_decisions"]["*"]} + if entry["decisions"]["superseded"] in active or len(active) != 4: + sys.exit(f"lifecycle: unexpected active decisions: {sorted(active)}") + stats = read["stats"] + if stats["fresh"]["redispatched"] != [entry["items"]["reclaimed"]] \ + or stats["fresh"]["reclaimed_stale"] != 1: + sys.exit(f"lifecycle: unexpected stats: {stats['fresh']!r}") + if stats["aged"]["blocked_aged"] == stats["fresh"]["blocked_aged"]: + sys.exit("lifecycle: the aged clock changed no stall count") + + +def _require_compacted(entry: dict, before: dict) -> None: + after = entry["release_read"] + rolled, mixed = entry["items"]["rolled"], entry["items"]["mixed"] + for label, read in (("before", before), ("after", after)): + fresh = read["stats"]["fresh"] + if sorted(fresh["redispatched"]) != sorted([rolled, mixed]) \ + or fresh["reclaimed_stale"] != 2: + sys.exit(f"compacted: stats {label} compaction: {fresh!r}") + if before["stats"] != after["stats"]: + sys.exit("compacted: the release's own stats changed across compaction") + rollups = {r["item_id"]: r["claim_count"] + for r in after["aggregates"].get("transition_rollups", [])} + counters = {r["name"]: r["value"] + for r in after["aggregates"].get("transition_counters", [])} + live = after["transitions"] + if rollups.get(rolled) != 2 or live[rolled]: + sys.exit(f"compacted: rolled is not wholly rolled up: {rollups!r} {live[rolled]!r}") + if rollups.get(mixed) != 1 or _claims(live[mixed]) != 1: + sys.exit(f"compacted: mixed does not split its claims: {rollups!r} {live[mixed]!r}") + if counters.get("reclaimed_stale") != 1 or not any( + t["note"] == "stale-claim recovery" for t in live[mixed]): + sys.exit(f"compacted: reclaims do not split: {counters!r} {live[mixed]!r}") + + +if __name__ == "__main__": + main() diff --git a/tests/fixtures/persisted/board/v0.1.2/bindings.json b/tests/fixtures/persisted/board/v0.1.2/bindings.json new file mode 100644 index 0000000..c4c6d7d --- /dev/null +++ b/tests/fixtures/persisted/board/v0.1.2/bindings.json @@ -0,0 +1,1557 @@ +{ + "box_root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpup2411q6", + "missing_dependency": "00000000-0000-4000-8000-000000000000", + "release": "0.1.2", + "scenarios": { + "crash-blocked": { + "decisions": {}, + "files": [ + "board.db" + ], + "frozen_at": 1794698668.965004, + "items": { + "crashed": "73ba618d-6255-4b7d-9be5-e69a8100fe1f", + "interrupted": "fa697534-212a-4918-b7b0-0be81b290879" + }, + "release_read": { + "active_decisions": { + "*": [] + }, + "aggregates": {}, + "boundary": { + "item": "73ba618d-6255-4b7d-9be5-e69a8100fe1f", + "stats": { + "after": { + "blocked_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "at": { + "blocked_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "before": { + "blocked_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "times": { + "after": 1794702268.9650042, + "at": 1794702268.965004, + "before": 1794702268.9650037 + } + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "73ba618d-6255-4b7d-9be5-e69a8100fe1f": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698667.57725, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "73ba618d-6255-4b7d-9be5-e69a8100fe1f", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "orchestration raises", + "updated_at": 1794698668.965004 + }, + "fa697534-212a-4918-b7b0-0be81b290879": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698664.676212, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "fa697534-212a-4918-b7b0-0be81b290879", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "interrupted by the operator", + "updated_at": 1794698666.826995 + } + }, + "order": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "stats": { + "aged": { + "blocked_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "fa697534-212a-4918-b7b0-0be81b290879", + "73ba618d-6255-4b7d-9be5-e69a8100fe1f" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "transitions": { + "73ba618d-6255-4b7d-9be5-e69a8100fe1f": [ + { + "actor": "human", + "at": 1794698667.57725, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "14971b36-7613-4006-b310-3ba051053413", + "at": 1794698668.964285, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698668.965004, + "from_state": "running", + "note": "orchestration crashed: RuntimeError: frozen: injected orchestration failure", + "to_state": "blocked" + } + ], + "fa697534-212a-4918-b7b0-0be81b290879": [ + { + "actor": "human", + "at": 1794698664.676212, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "05534c8c-56b0-438b-b8ce-1688c9b7206a", + "at": 1794698665.291122, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698666.826995, + "from_state": "running", + "note": "orchestration cancelled by operator (SIGINT)", + "to_state": "blocked" + } + ] + } + } + }, + "lifecycle": { + "decisions": { + "global": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "other-scope": "28e3851b-1711-42a4-a5e5-60fa734a51e9", + "replacement": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scoped": "296dc056-3c9e-4699-b044-d85baedd0d1a", + "superseded": "cb12bc01-96f6-4322-ae3a-6c4e9bb80f9f" + }, + "files": [ + "board.db" + ], + "frozen_at": 1794698661.102981, + "items": { + "agent-failed": "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "annotated": "3d5c3169-7023-4aa9-ad9d-62910fb767e6", + "bare-done-refused": "590a63d0-4d6b-43bc-a149-5a9ede88fbcb", + "evidence-done": "67ba43ad-2711-49b1-994f-af73fc7a6523", + "handed-off": "250805f5-fc0e-4ca3-8564-fa449f3e1855", + "human-blocked": "cd38d7ed-82f3-41c0-abad-841b590acf07", + "human-cleared": "f8e414fa-db58-4364-abc8-a26ade5ed297", + "human-required": "52e6c512-57f9-4c22-bd22-51e8427ea20f", + "imported-1": "db0ad772-7a10-587a-b48c-581e726e7b09", + "needs-done": "fa1452c9-a890-4136-8385-240cbea236bc", + "needs-missing": "d03a57bf-7d9c-4fdf-9169-69f55cd21a23", + "needs-planned": "fbca3bb1-35b9-4b27-994f-41367fbdd25b", + "needs-two": "fb34011e-6cab-4e76-a46a-ebc0c01b86fb", + "passed": "e80780d3-ea25-47d4-9e61-179e54db39ab", + "pipeline-gate-failed": "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "reclaimed": "5d99bb0d-60d3-4d03-99fa-3777680c1208", + "route-gate-failed": "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "signed-off": "cba2fe9d-c44e-4b28-a569-c54a2c40a32c", + "verified": "ed3507e2-101b-49d7-b88f-a2f4e20c55fb" + }, + "release_read": { + "active_decisions": { + "*": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698659.577112, + "id": "296dc056-3c9e-4699-b044-d85baedd0d1a", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698661.102981, + "id": "28e3851b-1711-42a4-a5e5-60fa734a51e9", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "backend": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698659.577112, + "id": "296dc056-3c9e-4699-b044-d85baedd0d1a", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ], + "docs": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698661.102981, + "id": "28e3851b-1711-42a4-a5e5-60fa734a51e9", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "nothing": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ], + "review": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ] + }, + "aggregates": {}, + "boundary": { + "item": "cd38d7ed-82f3-41c0-abad-841b590acf07", + "stats": { + "after": { + "blocked_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "cd38d7ed-82f3-41c0-abad-841b590acf07" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "250805f5-fc0e-4ca3-8564-fa449f3e1855" + ], + "false_done": [], + "human_required_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3" + ], + "reclaimed_stale": 1, + "redispatched": [ + "5d99bb0d-60d3-4d03-99fa-3777680c1208" + ], + "stall_seconds": 3600, + "total": 19 + }, + "at": { + "blocked_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "cd38d7ed-82f3-41c0-abad-841b590acf07" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "250805f5-fc0e-4ca3-8564-fa449f3e1855" + ], + "false_done": [], + "human_required_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3" + ], + "reclaimed_stale": 1, + "redispatched": [ + "5d99bb0d-60d3-4d03-99fa-3777680c1208" + ], + "stall_seconds": 3600, + "total": 19 + }, + "before": { + "blocked_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "250805f5-fc0e-4ca3-8564-fa449f3e1855" + ], + "false_done": [], + "human_required_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3" + ], + "reclaimed_stale": 1, + "redispatched": [ + "5d99bb0d-60d3-4d03-99fa-3777680c1208" + ], + "stall_seconds": 3600, + "total": 19 + } + }, + "times": { + "after": 1794702253.6544821, + "at": 1794702253.654482, + "before": 1794702253.6544816 + } + }, + "decision_rows": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698659.577112, + "id": "296dc056-3c9e-4699-b044-d85baedd0d1a", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698660.086337, + "id": "cb12bc01-96f6-4322-ae3a-6c4e9bb80f9f", + "scope": "", + "superseded_at": 1794698660.593653, + "superseded_by": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "text": "Tabs, not spaces." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698661.102981, + "id": "28e3851b-1711-42a4-a5e5-60fa734a51e9", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "decisions_mapped": [ + { + "created_at": 1794698659.07176, + "id": "a5219469-1a17-4ee4-aa0a-e837654e84d4", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698659.577112, + "id": "296dc056-3c9e-4699-b044-d85baedd0d1a", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698660.086337, + "id": "cb12bc01-96f6-4322-ae3a-6c4e9bb80f9f", + "scope": "", + "superseded_at": 1794698660.593653, + "superseded_by": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "text": "Tabs, not spaces." + }, + { + "created_at": 1794698660.593653, + "id": "a022b75e-fa2f-4ff0-9c13-b19a42b42c86", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698661.102981, + "id": "28e3851b-1711-42a4-a5e5-60fa734a51e9", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "items": { + "09b4c67a-ec4a-4732-8658-01d721dfc1b3": { + "blocked_reason": "All agents failed:\n [codex] codex (fake): refused", + "claimed_at": null, + "created_at": 1794698639.064196, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "none", + "state": "blocked", + "task": "ask a refusing agent", + "updated_at": 1794698640.572549 + }, + "250805f5-fc0e-4ca3-8564-fa449f3e1855": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698632.811248, + "depends_on": [], + "evidence": [ + { + "at": 1794698634.37516, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "backend", + "handoff": "검토: 부호를 확인할 것", + "human_required": false, + "id": "250805f5-fc0e-4ca3-8564-fa449f3e1855", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "notes/plan.md", + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "덧셈을 고친다", + "updated_at": 1794698634.37516 + }, + "3d5c3169-7023-4aa9-ad9d-62910fb767e6": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698654.1412852, + "depends_on": [], + "evidence": [ + { + "at": 1794698654.6227572, + "by": "human", + "kind": "manual", + "passed": true, + "ref": "https://example.invalid/log/7" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "3d5c3169-7023-4aa9-ad9d-62910fb767e6", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "carries a reference", + "updated_at": 1794698654.6228008 + }, + "52e6c512-57f9-4c22-bd22-51e8427ea20f": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698655.101978, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "52e6c512-57f9-4c22-bd22-51e8427ea20f", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "needs a person", + "updated_at": 1794698655.101978 + }, + "590a63d0-4d6b-43bc-a149-5a9ede88fbcb": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698652.167226, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "590a63d0-4d6b-43bc-a149-5a9ede88fbcb", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "no verification yet", + "updated_at": 1794698652.167226 + }, + "5d99bb0d-60d3-4d03-99fa-3777680c1208": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698641.113525, + "depends_on": [], + "evidence": [ + { + "at": 1794698646.1966789, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "5d99bb0d-60d3-4d03-99fa-3777680c1208", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698646.1966789 + }, + "67ba43ad-2711-49b1-994f-af73fc7a6523": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698646.730467, + "depends_on": [], + "evidence": [ + { + "at": 1794698648.338629, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + }, + { + "at": 1794698648.906337, + "by": "human", + "kind": "manual", + "passed": true, + "ref": "CI ✓ run 42 — grün" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "67ba43ad-2711-49b1-994f-af73fc7a6523", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "verified by CI", + "updated_at": 1794698648.906389 + }, + "cba2fe9d-c44e-4b28-a569-c54a2c40a32c": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698649.4325051, + "depends_on": [], + "evidence": [ + { + "at": 1794698651.0604858, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + }, + { + "at": 1794698651.638635, + "by": "human", + "kind": "human", + "passed": true, + "ref": "sign-off" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "cba2fe9d-c44e-4b28-a569-c54a2c40a32c", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "verified by a human", + "updated_at": 1794698651.638696 + }, + "cd38d7ed-82f3-41c0-abad-841b590acf07": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698653.167745, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "cd38d7ed-82f3-41c0-abad-841b590acf07", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "waits on ops", + "updated_at": 1794698653.654482 + }, + "d03a57bf-7d9c-4fdf-9169-69f55cd21a23": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698657.559104, + "depends_on": [ + "00000000-0000-4000-8000-000000000000" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "d03a57bf-7d9c-4fdf-9169-69f55cd21a23", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after an item that does not exist", + "updated_at": 1794698657.559104 + }, + "db0ad772-7a10-587a-b48c-581e726e7b09": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698658.567849, + "depends_on": [], + "evidence": [ + { + "at": 1794698658.567849, + "by": "tracegraph", + "kind": "tracegraph", + "passed": false, + "ref": "sha256:2469307ff4b7bc62fd803a18822f3d26c6620bfaa06e0037db62082f6c9c528b" + } + ], + "goal": "review", + "handoff": "", + "human_required": true, + "id": "db0ad772-7a10-587a-b48c-581e726e7b09", + "inputs": [ + "source:tracegraph.review-candidates@v1", + "run_id:efd16fc1-758e-48fd-a765-bb3e27815952", + "pattern:tool-retry-failure@v2", + "tool_key:syncmill::board_stats", + "artifact_digest:sha256:2469307ff4b7bc62fd803a18822f3d26c6620bfaa06e0037db62082f6c9c528b" + ], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "review", + "task": "Review Tracegraph tool-retry-failure@v2 finding for syncmill::board_stats", + "updated_at": 1794698658.567849 + }, + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1": { + "blocked_reason": "quality gate failed: 0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"", + "claimed_at": null, + "created_at": 1794698636.983017, + "depends_on": [], + "evidence": [ + { + "at": 1794698638.513152, + "by": "codex", + "kind": "gate", + "passed": false, + "ref": "0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"" + } + ], + "goal": "", + "handoff": "", + "human_required": true, + "id": "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "codex", + "state": "blocked", + "task": "fix add badly in a pipeline", + "updated_at": 1794698638.513152 + }, + "e80780d3-ea25-47d4-9e61-179e54db39ab": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698628.608104, + "depends_on": [], + "evidence": [ + { + "at": 1794698630.214753, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "e80780d3-ea25-47d4-9e61-179e54db39ab", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698630.214753 + }, + "ed0d53d3-6670-4949-8557-b38f8f7a1465": { + "blocked_reason": "All agents failed:\n [codex] quality gate failed: 0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"", + "claimed_at": null, + "created_at": 1794698634.904182, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "none", + "state": "blocked", + "task": "fix add badly", + "updated_at": 1794698636.43021 + }, + "ed3507e2-101b-49d7-b88f-a2f4e20c55fb": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698630.7539961, + "depends_on": [], + "evidence": [ + { + "at": 1794698632.287241, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "backend", + "handoff": "", + "human_required": false, + "id": "ed3507e2-101b-49d7-b88f-a2f4e20c55fb", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "fix add and finish", + "updated_at": 1794698632.287241 + }, + "f8e414fa-db58-4364-abc8-a26ade5ed297": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698655.5769348, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "f8e414fa-db58-4364-abc8-a26ade5ed297", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "needed a person", + "updated_at": 1794698656.059977 + }, + "fa1452c9-a890-4136-8385-240cbea236bc": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698656.5677388, + "depends_on": [ + "ed3507e2-101b-49d7-b88f-a2f4e20c55fb" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "fa1452c9-a890-4136-8385-240cbea236bc", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after the verified item", + "updated_at": 1794698656.5677388 + }, + "fb34011e-6cab-4e76-a46a-ebc0c01b86fb": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698658.060055, + "depends_on": [ + "ed3507e2-101b-49d7-b88f-a2f4e20c55fb", + "3d5c3169-7023-4aa9-ad9d-62910fb767e6" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "fb34011e-6cab-4e76-a46a-ebc0c01b86fb", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after two items", + "updated_at": 1794698658.060055 + }, + "fbca3bb1-35b9-4b27-994f-41367fbdd25b": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698657.056418, + "depends_on": [ + "3d5c3169-7023-4aa9-ad9d-62910fb767e6" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "fbca3bb1-35b9-4b27-994f-41367fbdd25b", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after a planned item", + "updated_at": 1794698657.056418 + } + }, + "order": [ + "e80780d3-ea25-47d4-9e61-179e54db39ab", + "ed3507e2-101b-49d7-b88f-a2f4e20c55fb", + "250805f5-fc0e-4ca3-8564-fa449f3e1855", + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "5d99bb0d-60d3-4d03-99fa-3777680c1208", + "67ba43ad-2711-49b1-994f-af73fc7a6523", + "cba2fe9d-c44e-4b28-a569-c54a2c40a32c", + "590a63d0-4d6b-43bc-a149-5a9ede88fbcb", + "cd38d7ed-82f3-41c0-abad-841b590acf07", + "3d5c3169-7023-4aa9-ad9d-62910fb767e6", + "52e6c512-57f9-4c22-bd22-51e8427ea20f", + "f8e414fa-db58-4364-abc8-a26ade5ed297", + "fa1452c9-a890-4136-8385-240cbea236bc", + "fbca3bb1-35b9-4b27-994f-41367fbdd25b", + "d03a57bf-7d9c-4fdf-9169-69f55cd21a23", + "fb34011e-6cab-4e76-a46a-ebc0c01b86fb", + "db0ad772-7a10-587a-b48c-581e726e7b09" + ], + "stats": { + "aged": { + "blocked_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "cd38d7ed-82f3-41c0-abad-841b590acf07" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "250805f5-fc0e-4ca3-8564-fa449f3e1855" + ], + "false_done": [], + "human_required_aged": [ + "ed0d53d3-6670-4949-8557-b38f8f7a1465", + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1", + "09b4c67a-ec4a-4732-8658-01d721dfc1b3", + "52e6c512-57f9-4c22-bd22-51e8427ea20f", + "db0ad772-7a10-587a-b48c-581e726e7b09" + ], + "reclaimed_stale": 1, + "redispatched": [ + "5d99bb0d-60d3-4d03-99fa-3777680c1208" + ], + "stall_seconds": 3600, + "total": 19 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 1, + "redispatched": [ + "5d99bb0d-60d3-4d03-99fa-3777680c1208" + ], + "stall_seconds": 3600, + "total": 19 + } + }, + "transitions": { + "09b4c67a-ec4a-4732-8658-01d721dfc1b3": [ + { + "actor": "human", + "at": 1794698639.064196, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "acbe6df4-c07f-43d9-ab21-d3832a18538f", + "at": 1794698640.161309, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "none", + "at": 1794698640.572549, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "250805f5-fc0e-4ca3-8564-fa449f3e1855": [ + { + "actor": "human", + "at": 1794698632.811248, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "ad3df32b-9c9f-432f-b2cd-85b2861fcd66", + "at": 1794698633.918839, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698634.37516, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "3d5c3169-7023-4aa9-ad9d-62910fb767e6": [ + { + "actor": "human", + "at": 1794698654.1412852, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698654.6228008, + "from_state": "planned", + "note": "annotated", + "to_state": "planned" + } + ], + "52e6c512-57f9-4c22-bd22-51e8427ea20f": [ + { + "actor": "human", + "at": 1794698655.101978, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "590a63d0-4d6b-43bc-a149-5a9ede88fbcb": [ + { + "actor": "human", + "at": 1794698652.167226, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "5d99bb0d-60d3-4d03-99fa-3777680c1208": [ + { + "actor": "human", + "at": 1794698641.113525, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "8628b3d3-5984-41ca-ab2d-5188935c6ec8", + "at": 1794698642.242814, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698645.181956, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "db8ffa31-0ff2-41b9-ab2e-a2c8ee2eb108", + "at": 1794698645.774993, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698646.1966789, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "67ba43ad-2711-49b1-994f-af73fc7a6523": [ + { + "actor": "human", + "at": 1794698646.730467, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "4e950744-afa9-4a60-b518-6236f74e78be", + "at": 1794698647.853072, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698648.338629, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + }, + { + "actor": "human", + "at": 1794698648.906389, + "from_state": "review", + "note": "", + "to_state": "done" + } + ], + "cba2fe9d-c44e-4b28-a569-c54a2c40a32c": [ + { + "actor": "human", + "at": 1794698649.4325051, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "a4e7383d-eb2d-4f3e-bc14-31e3c13d31a2", + "at": 1794698650.589119, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698651.0604858, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + }, + { + "actor": "human", + "at": 1794698651.638696, + "from_state": "review", + "note": "", + "to_state": "done" + } + ], + "cd38d7ed-82f3-41c0-abad-841b590acf07": [ + { + "actor": "human", + "at": 1794698653.167745, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698653.654482, + "from_state": "planned", + "note": "waiting on ops", + "to_state": "blocked" + } + ], + "d03a57bf-7d9c-4fdf-9169-69f55cd21a23": [ + { + "actor": "human", + "at": 1794698657.559104, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "db0ad772-7a10-587a-b48c-581e726e7b09": [ + { + "actor": "tracegraph-import", + "at": 1794698658.567849, + "from_state": null, + "note": "imported review candidate", + "to_state": "review" + } + ], + "e2b2d0e1-1042-49bd-b09d-f8574b086ef1": [ + { + "actor": "human", + "at": 1794698636.983017, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "cb05fc5d-cc05-4cca-8c0c-44c76cfacf33", + "at": 1794698638.0754921, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698638.513152, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "e80780d3-ea25-47d4-9e61-179e54db39ab": [ + { + "actor": "human", + "at": 1794698628.608104, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "8763a631-fac4-4b9a-b102-ad4fb49e7cb3", + "at": 1794698629.1479979, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698630.214753, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "ed0d53d3-6670-4949-8557-b38f8f7a1465": [ + { + "actor": "human", + "at": 1794698634.904182, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "9e1507ff-30b9-49e1-8276-22b8bef585f2", + "at": 1794698636.0288231, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "none", + "at": 1794698636.43021, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "ed3507e2-101b-49d7-b88f-a2f4e20c55fb": [ + { + "actor": "human", + "at": 1794698630.7539961, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "c2451fa6-eb7c-4468-ad55-edb97bc22b24", + "at": 1794698631.854018, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698632.287241, + "from_state": "running", + "note": "agent completed; verified", + "to_state": "done" + } + ], + "f8e414fa-db58-4364-abc8-a26ade5ed297": [ + { + "actor": "human", + "at": 1794698655.5769348, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698656.059977, + "from_state": "planned", + "note": "annotated", + "to_state": "planned" + } + ], + "fa1452c9-a890-4136-8385-240cbea236bc": [ + { + "actor": "human", + "at": 1794698656.5677388, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "fb34011e-6cab-4e76-a46a-ebc0c01b86fb": [ + { + "actor": "human", + "at": 1794698658.060055, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "fbca3bb1-35b9-4b27-994f-41367fbdd25b": [ + { + "actor": "human", + "at": 1794698657.056418, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ] + } + } + }, + "running": { + "decisions": {}, + "files": [ + "board.db", + "board.db-shm", + "board.db-wal" + ], + "frozen_at": 1794698662.841047, + "items": { + "killed": "0fe98d25-4f1e-437f-a0bc-0c28cdbc6fcc", + "waiting": "eba73a32-22cd-4052-8cfb-c1bc12fb40bb" + }, + "release_read": { + "active_decisions": { + "*": [], + "backend": [] + }, + "aggregates": {}, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "0fe98d25-4f1e-437f-a0bc-0c28cdbc6fcc": { + "blocked_reason": "", + "claimed_at": 1794698662.841047, + "created_at": 1794698662.309786, + "depends_on": [], + "evidence": [], + "goal": "backend", + "handoff": "", + "human_required": false, + "id": "0fe98d25-4f1e-437f-a0bc-0c28cdbc6fcc", + "inputs": [], + "lease_run_id": "c8eecea0-a585-42e8-aa9d-dff948c5b960", + "outputs": [], + "owner_agent": null, + "state": "running", + "task": "killed mid-run", + "updated_at": 1794698662.841047 + }, + "eba73a32-22cd-4052-8cfb-c1bc12fb40bb": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698661.811179, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "eba73a32-22cd-4052-8cfb-c1bc12fb40bb", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "still planned", + "updated_at": 1794698661.811179 + } + }, + "order": [ + "eba73a32-22cd-4052-8cfb-c1bc12fb40bb", + "0fe98d25-4f1e-437f-a0bc-0c28cdbc6fcc" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "planned": 1, + "running": 1 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "planned": 1, + "running": 1 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "transitions": { + "0fe98d25-4f1e-437f-a0bc-0c28cdbc6fcc": [ + { + "actor": "human", + "at": 1794698662.309786, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "c8eecea0-a585-42e8-aa9d-dff948c5b960", + "at": 1794698662.841047, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + } + ], + "eba73a32-22cd-4052-8cfb-c1bc12fb40bb": [ + { + "actor": "human", + "at": 1794698661.811179, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ] + } + } + } + }, + "stall_seconds": 3600, + "tracegraph_report": "tests/fixtures/tracegraph/v1.json" +} diff --git a/tests/fixtures/persisted/board/v0.1.2/crash-blocked/board.db b/tests/fixtures/persisted/board/v0.1.2/crash-blocked/board.db new file mode 100644 index 0000000000000000000000000000000000000000..8b71a7e445d2ef7a69198a75e06cf249d09d894e GIT binary patch literal 69632 zcmeI*&2Qsq9S3mRY2&7C>Q;;tEj`p#g_3A$h@00AFQRlqx3t??x{0)-Q3-bZw9PcN zv$nG{U9E(=3o9WGoZ-YC;WC#Md)ou>7jPOO?TyO{A;bYK5*&CQza-8iX|ocnG~w%+ zwtji+=XpNACwA<#&-42C4_hvgPc8dWbLBj@%n1VbZCU0xPM}{a^edbe>C8;HK!5U) z`Ej!X_tp2aN$H>5^6VA2_y_6ti~6Fl@Qa17CH|H8bz*n!ONnLiL-8QKDhf0KCI~

Y&J9AGAz^JZTwE8oH&~M#Ju!4O6=$PDg7Jr_t%!XT%t_X=V4gx>Kvl z`$sQV-;i%Pz`RVS`$zJq17-X?8k)N)H``k4k{EP8du=R0wiS*Fv_nr`bY(pz2{3SDngkd(!$w=Uy!JH&SA z{zgN;%APF7Q~5Ri@rZn!rq$_Zle{4tFQwNcBH6ILv)6CWi>b9W{=HounT3G} z_f`jC4MXb1bttfYkX-V_^|!O{Bcd3TE=V(wKz_OU-JSYjjkbs&;x^G-ugS9HBVs`}nOvU5KZuYvWo&udWTXH@j#g;;G^W|D#?wTw61pmg@zcwbsb;{7^(9 z8yhS!3w&fyLb5qUQB{!>X0|P#H42lztx6|iGlb$w=u)cEt@oH_FYvJ zQyUxnkF(w}Bbi2K=LU`y*)SaK{i9lSuX;T2GTy1z?(ZMbW4u~Ds`=_cg;=Zx;_7cb zwXMsBBc_}E!3;f{tVhl!{o^*yEUn#NoV_Uw`U|Gigv&aY&E zLwC>|%N#rx_0opd7=v_(X*dmkYL(AER%v=h)lqB>fVkuW-`O={HOefB*y_009U<00Izz00bZafhiNX zz9X#Elf_kTWo0Efmt3ifqFB!BT1l-KN@=TDR0?|8P_}haRLFTGZ6ZlO6TcyCX1XQAbK=lvrtDF$Y-=rtIKfkghbR8Ooj-m2^+$jH`)}CKi*Nq!R~Ao8wdbR8)OyJ69=hw@jDVcDF+xgUkAr?4A>uKFOyU zTlT07@9s%n#vlImop~BpL3+wbPo-y57GhKf0uX=z1Rwwb2tWV=5P$##An>9JWMXxG z>|=_^qX!`!t0yLTa^TmxudY?oC%UsB2?HLnzMxssyi)to|mILsB*T(Nim&-(w5C*R|wkEBr`vCyEX~CqQ9J- zW2LIEPE@F1_`#rTx7~i`3u-T_l14fz+0p6B&wPrK50V_vym zBH|?d-%Wt2(a{RqZNF#zuvdLK^ZNcC9bqsV_M?9(gj$p2I;fQ^((e76m8McG(SH34 z`HHUSl_pWtQl-+|*2`PDk`~c=bo{}`dwi(%IkFqlqT>Lt`+r{g8%O_Rf&c^{009U< z00Izz00bZa0SG`~Is_y>w!za82~DTP1|@Xj?C<~M(gG))NCjy@dPc_qe1AHsidsMb z0uX=z1Rwwb2tWV=5P$##MhZ+iwqAVFgtL<-oM8zk`5-?wX~K!e|6`y3bIT(=uo40g zfB*y_009U<00Izz00bZafhiGSpa0|je@cRhYCr%25P$##AOHafKmY;|fB*!>2;lyI z3=CF700Izz00bZa0SG_<0uX=z1g1y;_y1EAOjHE|5P$##AOHafKmY;|fB*y_Fh+p= z{l6f6kCQ&2-!MS{0uX=z1Rwwb2tWV=5P$##AaIL7U6`%cMQ)Oz56gL7E2$MjDQy*t zNgF%f?5AO0S|e*kUBG9>^2 literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.1.2/lifecycle/board.db b/tests/fixtures/persisted/board/v0.1.2/lifecycle/board.db new file mode 100644 index 0000000000000000000000000000000000000000..c57d9e22ef5ce7c96127026787e29242800de004 GIT binary patch literal 77824 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 D-{*h0 literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.1.2/running/board.db b/tests/fixtures/persisted/board/v0.1.2/running/board.db new file mode 100644 index 0000000000000000000000000000000000000000..3dde73ce0e5e3924876a110b9e85ccbf1de6c9b3 GIT binary patch literal 69632 zcmeI*&2QUe90zdQX_F>xa4QZue(uNIz5Ty&HYL|_YNSmr*9NX!vCUzD( z>xPg}$BTqGa^k=rz-bpGZd~9$;DY!M#)Vzbkl?^$KYmN&wAIF;gs;0a_T$IT%jfsl zj-91>@7-P9)`Yg%@5;8Y#>_Ju$Gj;B48w5bu|OXFG)HEp`~~vNM&`%Oa?DGgi&_3p zW`6nsGxrn!<6LWwoBewB<@8_aZ_}GIFQ(^H-=%hv`4mSoV1fVyAn<<>I9{Aj<#wv< z@s4h&+I?NUFSSg$uS)%aAsKR4vwE_kSyFG%KhV^;RSTPYwT(ti*sfo#-4xC!AS00J zdR>Sss7ULOWP3$WIrEpE%WG~R1gW8> zQC)S~B?yh$&4zGeZ~NND-YsFLc1zfNr?$Bx6umsJzabO~;)=T&IbC)A?cB}k*Be5; zxw}hOhaC_E;-YRYmT)by z$EhHos;20cZW@*(E4F@53zlCP30<(t%j(1`NGn={p4PX>_Nvr+Al{x!=GGS3qnLUu z#q5REWKXHa&FKz_NHxyZ;_-)>RBmyR{bbXPd$2l~nH`F7knDxk52+j1k-*X*+1h=Z zu6KUNMA2)VmuD!0aJBaKMsv48MuZpfz9!r5kae=h#C%B4t&MINNhhy;=x8X|18v zDelDDk%3~Eq*OW$)jX1sj0S%i8crGUPLk~7OVNG&$m}1wfwQEJCR6xyZ1Mdmax__r98JP< zr2|v$gp1RsRpVrJ4<}*%qLU_mkRZFq68j*oA8w$-4W>@3fDVdbF*i;8>?1anTUuhj zqzA09yl{^5N~R~JFnx3slfb)!BXTmLBa?Q}9~Y+&AX~N${hTL8rFZCYN4TG5Okur_ zY#5qaa8G-FUi$2v9;wN8T__g(%qsnMA3Zi!^ zjSK@)tkVi_7d3hV+wyB1)4KiJ-tpHQ*pcjK$D$ywe~wYLo@S_)L^6_TOgjRR z=#Ct9jlMRaXDZqh<*YNYWa`InmYC61h*~-L%=iO@B6i{oytJ ztDnE{pJjHTnJo-erM2YCYw}v9RH-OxX??X?DP2+8t&&o1DdkGLwZ7VFSvILe@XC&> z!uoCBt%5vfNUu2l5yL;?e?f>L009U<00Izz00bZa0SG_<0uZwm=JiD?eA=6* z*Z)r#{%`)tvlosnApijgKmY;|fB*y_009U<00I!WNCM7n0Pmv+Tq2Q8)9e4I&h`J( zi_}iE1p*L&00bZa0SG_<0uX=z1Rwx`=N6bsFf6(LXK?-h+>|H)0uX=z1Rwwb2tWV= z5P$##AaG#?g6n_!_x}xs|DHE4Y-`al2tWV=5P$##AOHafKmY;|fWUuBV2hh!noK^I zKi5|VcpuSszt_4Ecu%0uX=z1Rwwb2tWV= z5P$##AOL~M5a8LwGHdr`!_sZtG%OC^|2G+dMK2%#0SG_<0uX=z1Rwwb2tZ(>1pf8! z|8w5|XXYo$2%Uid1Rwwb2tWV=5P$##AOHafK;VRc^Zq}s|4*P`5dsi^00bZa0SG_< z0uX=z1RyYB0=WL4uz;dF5P$##AOHafKmY;|fB*y_0D%|*T>r_Z5P$##AOHafKmY;|fB*y_5F_vp+3O9+ literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.1.2/running/board.db-shm b/tests/fixtures/persisted/board/v0.1.2/running/board.db-shm new file mode 100644 index 0000000000000000000000000000000000000000..2cce4dd5abf13efb177201f7529281551b9629e0 GIT binary patch literal 32768 zcmeI*v2DUY6b4`dj)4dX)3E?$BsO3dDnvuc0+c8lWPucHkvdJ30Ww6&z_V6|Oo&IxuY;{iV zd%Vl_^X<`%w<_9?4x+jKDLRfe(flVNK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!8A71oF%m zAwYltfwBbhye%O>fB*pk1PGKN&?{q1QxfQ_69Q!l79QnzSh{ibD|*r<;nx{fkZioRX#>f`5mC z;-5hr>*AnwP#5W-xQKJXI23iUAfk(4t&^bd+FTJ_u3(|9-LHKx*5GMO}seqX`M=8asj%Qte}y+y+| z9oI13Y{B&$x2Nd3j_nTnfj3+l8S%Zg(UNDB#{=~YO2Mgt6H5=b;QOv`n}(e)sLrx} z!LaQ<&+v-HzFfi0JAFOop|>v%l%7_n7x%ZTSEKi~mbOwI%fk{Pne-jIx7+T{8riJt z896hbH41LgG2AZ4?aCINoas1Y6*Zu?Gb45o_+D)n4QH|Iu`dJBUM*`~xU^Bc;LgG| zbExCwWV1S!ke`KIP#YQo2q1s}0tg_000IagfB*srtZ#u$dPb{-EE3Inrl}S$P?JiA z6N};kT2JSLgZD0prMN&<$e*&hz9-J;5kLR|1Q0*~0R#|0009IL_^$-^>6R8JOCh1_ zqDjd#hB{GP;CuCWaJ1!7IjkelxBL=vS_W!ILjVB;5I_I{1Q0*~0R#|0U?U2Q>W#w6 zWUNfAx`Em~_S$XtIN!b95xX?%dr@IPe?nbOWOlCTa)aZecHowMyHe{&RT}hbQAcqK z3u@#3t0PrUpcXZZ4J^k6=FYt@-JSn76UGHJ`BkVV4FLoYKmY**5I_I{1Q0*~0R%RN zfYkIoTBU3UW2H*zbTFo?X@w;N%W;93+{cb5$MQSEgSwm$^0Azdv*8&u1Q0*~0R#|0 z009ILKmY**5Lg|7F!evq4;|`pPfT>^R#Ti*0yQ5Q&MB%Rc)sm?Yx~*B8%y~DQ$kLy z&W!050R#|0009ILKmY**5I_I{1XdtmY4w(s6mg0d;zSst$_6!p#Xm5N;sUexD~GGE zTRw#O0-8z`AXi`oYs9GtAb3;YI&%4mH6 literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.2.0/bindings.json b/tests/fixtures/persisted/board/v0.2.0/bindings.json new file mode 100644 index 0000000..8119b5d --- /dev/null +++ b/tests/fixtures/persisted/board/v0.2.0/bindings.json @@ -0,0 +1,2015 @@ +{ + "box_root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpv85ishkt", + "missing_dependency": "00000000-0000-4000-8000-000000000000", + "release": "0.2.0", + "scenarios": { + "compacted": { + "before_compaction": { + "active_decisions": { + "*": [] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "decision_rows": [], + "decisions_mapped": [], + "frozen_at": 1794698724.9303622, + "items": { + "38a4eb0e-6f63-4136-bdb7-aecebb384994": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698723.688433, + "depends_on": [], + "evidence": [ + { + "at": 1794698724.9303622, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "38a4eb0e-6f63-4136-bdb7-aecebb384994", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698724.9303622 + }, + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698714.736595, + "depends_on": [], + "evidence": [ + { + "at": 1794698723.098138, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a later crash", + "updated_at": 1794698723.098138 + }, + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698709.73811, + "depends_on": [], + "evidence": [ + { + "at": 1794698714.145309, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698714.145309 + } + }, + "order": [ + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde", + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "38a4eb0e-6f63-4136-bdb7-aecebb384994" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde" + ], + "stall_seconds": 3600, + "total": 3 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde" + ], + "stall_seconds": 3600, + "total": 3 + } + }, + "transitions": { + "38a4eb0e-6f63-4136-bdb7-aecebb384994": [ + { + "actor": "human", + "at": 1794698723.688433, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "fa6db59f-ed84-46e9-84af-f735377e54d5", + "at": 1794698724.332741, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698724.9303622, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2": [ + { + "actor": "human", + "at": 1794698714.736595, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "4a88c995-ec11-4a6c-b921-ff4a7757057c", + "at": 1794698715.370608, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698722.522509, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "41ad381d-ea7d-4a7f-8b68-11043cbd031c", + "at": 1794698722.5228841, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698723.098138, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde": [ + { + "actor": "human", + "at": 1794698709.73811, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "e5c8c080-3332-49de-b9e2-71af3b4be14e", + "at": 1794698710.380436, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698713.545851, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "7f9fbf8a-c641-46be-b8c9-15bee55b2ee0", + "at": 1794698713.546366, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698714.145309, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ] + } + }, + "decisions": {}, + "files": [ + "board.db", + "board.db.gc-lock" + ], + "frozen_at": 1794698724.9303622, + "items": { + "mixed": "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "passed": "38a4eb0e-6f63-4136-bdb7-aecebb384994", + "rolled": "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde" + }, + "release_read": { + "active_decisions": { + "*": [] + }, + "aggregates": { + "transition_counters": [ + { + "name": "reclaimed_stale", + "value": 1 + } + ], + "transition_rollups": [ + { + "claim_count": 1, + "item_id": "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2" + }, + { + "claim_count": 2, + "item_id": "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde" + } + ] + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "38a4eb0e-6f63-4136-bdb7-aecebb384994": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698723.688433, + "depends_on": [], + "evidence": [ + { + "at": 1794698724.9303622, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "38a4eb0e-6f63-4136-bdb7-aecebb384994", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698724.9303622 + }, + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698714.736595, + "depends_on": [], + "evidence": [ + { + "at": 1794698723.098138, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a later crash", + "updated_at": 1794698723.098138 + }, + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698709.73811, + "depends_on": [], + "evidence": [ + { + "at": 1794698714.145309, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698714.145309 + } + }, + "order": [ + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde", + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "38a4eb0e-6f63-4136-bdb7-aecebb384994" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde" + ], + "stall_seconds": 3600, + "total": 3 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2", + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde" + ], + "stall_seconds": 3600, + "total": 3 + } + }, + "transitions": { + "38a4eb0e-6f63-4136-bdb7-aecebb384994": [ + { + "actor": "human", + "at": 1794698723.688433, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "fa6db59f-ed84-46e9-84af-f735377e54d5", + "at": 1794698724.332741, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698724.9303622, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "66df6f1f-e77e-45fd-bb53-ee80c30ee9d2": [ + { + "actor": "system", + "at": 1794698722.522509, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "41ad381d-ea7d-4a7f-8b68-11043cbd031c", + "at": 1794698722.5228841, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698723.098138, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "b66ac996-f4bb-4a4c-ac2a-00c3f3bb7cde": [] + } + } + }, + "crash-blocked": { + "decisions": {}, + "files": [ + "board.db" + ], + "frozen_at": 1794698708.938221, + "items": { + "crashed": "fce654b0-a66e-4025-aed5-1f1f231ca6dd", + "interrupted": "830ba165-c068-47d0-b062-dde4d9edc8f7" + }, + "release_read": { + "active_decisions": { + "*": [] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "boundary": { + "item": "fce654b0-a66e-4025-aed5-1f1f231ca6dd", + "stats": { + "after": { + "blocked_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "at": { + "blocked_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "before": { + "blocked_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "times": { + "after": 1794702308.9382212, + "at": 1794702308.938221, + "before": 1794702308.9382207 + } + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "830ba165-c068-47d0-b062-dde4d9edc8f7": { + "blocked_reason": "orchestration cancelled by operator (SIGINT)", + "claimed_at": null, + "created_at": 1794698706.51917, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "830ba165-c068-47d0-b062-dde4d9edc8f7", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "interrupted by the operator", + "updated_at": 1794698707.687259 + }, + "fce654b0-a66e-4025-aed5-1f1f231ca6dd": { + "blocked_reason": "orchestration crashed: RuntimeError: frozen: injected orchestration failure", + "claimed_at": null, + "created_at": 1794698708.296758, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "fce654b0-a66e-4025-aed5-1f1f231ca6dd", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "orchestration raises", + "updated_at": 1794698708.938221 + } + }, + "order": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "stats": { + "aged": { + "blocked_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "830ba165-c068-47d0-b062-dde4d9edc8f7", + "fce654b0-a66e-4025-aed5-1f1f231ca6dd" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "transitions": { + "830ba165-c068-47d0-b062-dde4d9edc8f7": [ + { + "actor": "human", + "at": 1794698706.51917, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "26ded5cf-6699-415f-86b6-44bd600d3388", + "at": 1794698707.1460102, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698707.687259, + "from_state": "running", + "note": "orchestration cancelled by operator (SIGINT)", + "to_state": "blocked" + } + ], + "fce654b0-a66e-4025-aed5-1f1f231ca6dd": [ + { + "actor": "human", + "at": 1794698708.296758, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "8432681a-71c7-47d5-84f7-f31c77f787bc", + "at": 1794698708.937366, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698708.938221, + "from_state": "running", + "note": "orchestration crashed: RuntimeError: frozen: injected orchestration failure", + "to_state": "blocked" + } + ] + } + } + }, + "lifecycle": { + "decisions": { + "global": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "other-scope": "99c3daef-8147-48cb-abeb-7b842c6ab0da", + "replacement": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scoped": "1ff40700-3a13-4eb1-82c0-df0f990651e8", + "superseded": "8582ff36-6ca3-4848-841d-ce32c1fa0c66" + }, + "files": [ + "board.db", + "board.db.gc-lock" + ], + "frozen_at": 1794698703.200497, + "items": { + "agent-failed": "f5cb4597-7808-46ab-8f59-debe82245705", + "annotated": "439e0971-097a-43d8-9b40-26bab7fcd3a4", + "bare-done-refused": "48612b52-f063-47d1-82b0-f9463462fd09", + "evidence-done": "82af13a6-2af7-4a89-99b5-cb76f17f38d6", + "handed-off": "c7e03b49-63e9-43cb-8812-7e64e3540945", + "human-blocked": "3e7efe25-07e3-45da-8e63-6e9ed7c37bed", + "human-cleared": "0b7b1a14-7073-41ad-9a7d-062ee8c0148c", + "human-required": "e29da672-99dd-4f00-8256-eb49ac361207", + "imported-1": "db0ad772-7a10-587a-b48c-581e726e7b09", + "needs-done": "9d0ec325-02d4-4d12-a45e-60ae52f2df82", + "needs-missing": "0632579b-7a48-4acc-9877-087a27d146bf", + "needs-planned": "926acf3f-8331-4ffc-9878-743004594319", + "needs-two": "5c7adc0d-d21d-4064-ba3b-32ab946bcc80", + "passed": "3e42aab6-7ce1-45eb-aac4-826a6dfcc78b", + "pipeline-gate-failed": "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "reclaimed": "4dc5d162-1dc5-452c-8ad4-efebc110f4ab", + "route-gate-failed": "db0e439a-57dc-4e10-a956-d0f7b4807781", + "signed-off": "55907557-c8d1-4a3b-8242-c39e85bc24d8", + "verified": "2424fc1b-2463-48ca-8368-561083b6b32a" + }, + "release_read": { + "active_decisions": { + "*": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698701.433802, + "id": "1ff40700-3a13-4eb1-82c0-df0f990651e8", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698703.200497, + "id": "99c3daef-8147-48cb-abeb-7b842c6ab0da", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "backend": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698701.433802, + "id": "1ff40700-3a13-4eb1-82c0-df0f990651e8", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ], + "docs": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698703.200497, + "id": "99c3daef-8147-48cb-abeb-7b842c6ab0da", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "nothing": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ], + "review": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "boundary": { + "item": "3e7efe25-07e3-45da-8e63-6e9ed7c37bed", + "stats": { + "after": { + "blocked_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705", + "3e7efe25-07e3-45da-8e63-6e9ed7c37bed" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "c7e03b49-63e9-43cb-8812-7e64e3540945" + ], + "false_done": [], + "human_required_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705" + ], + "reclaimed_stale": 1, + "redispatched": [ + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab" + ], + "stall_seconds": 3600, + "total": 19 + }, + "at": { + "blocked_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705", + "3e7efe25-07e3-45da-8e63-6e9ed7c37bed" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "c7e03b49-63e9-43cb-8812-7e64e3540945" + ], + "false_done": [], + "human_required_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705" + ], + "reclaimed_stale": 1, + "redispatched": [ + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab" + ], + "stall_seconds": 3600, + "total": 19 + }, + "before": { + "blocked_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "c7e03b49-63e9-43cb-8812-7e64e3540945" + ], + "false_done": [], + "human_required_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705" + ], + "reclaimed_stale": 1, + "redispatched": [ + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab" + ], + "stall_seconds": 3600, + "total": 19 + } + }, + "times": { + "after": 1794702294.361, + "at": 1794702294.3609998, + "before": 1794702294.3609996 + } + }, + "decision_rows": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698701.433802, + "id": "1ff40700-3a13-4eb1-82c0-df0f990651e8", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698702.025722, + "id": "8582ff36-6ca3-4848-841d-ce32c1fa0c66", + "scope": "", + "superseded_at": 1794698702.6140192, + "superseded_by": "358e296b-d874-4e27-a720-3769aecd1ef3", + "text": "Tabs, not spaces." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698703.200497, + "id": "99c3daef-8147-48cb-abeb-7b842c6ab0da", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "decisions_mapped": [ + { + "created_at": 1794698700.838753, + "id": "c0602ab1-9fa4-4221-9ee0-81e089f61624", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698701.433802, + "id": "1ff40700-3a13-4eb1-82c0-df0f990651e8", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698702.025722, + "id": "8582ff36-6ca3-4848-841d-ce32c1fa0c66", + "scope": "", + "superseded_at": 1794698702.6140192, + "superseded_by": "358e296b-d874-4e27-a720-3769aecd1ef3", + "text": "Tabs, not spaces." + }, + { + "created_at": 1794698702.6140192, + "id": "358e296b-d874-4e27-a720-3769aecd1ef3", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698703.200497, + "id": "99c3daef-8147-48cb-abeb-7b842c6ab0da", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "items": { + "0632579b-7a48-4acc-9877-087a27d146bf": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698699.065164, + "depends_on": [ + "00000000-0000-4000-8000-000000000000" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "0632579b-7a48-4acc-9877-087a27d146bf", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after an item that does not exist", + "updated_at": 1794698699.065164 + }, + "0b7b1a14-7073-41ad-9a7d-062ee8c0148c": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698696.702538, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "0b7b1a14-7073-41ad-9a7d-062ee8c0148c", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "needed a person", + "updated_at": 1794698697.2933462 + }, + "2424fc1b-2463-48ca-8368-561083b6b32a": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698672.8998332, + "depends_on": [], + "evidence": [ + { + "at": 1794698674.222513, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "backend", + "handoff": "", + "human_required": false, + "id": "2424fc1b-2463-48ca-8368-561083b6b32a", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "fix add and finish", + "updated_at": 1794698674.222513 + }, + "3e42aab6-7ce1-45eb-aac4-826a6dfcc78b": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698670.41087, + "depends_on": [], + "evidence": [ + { + "at": 1794698672.084589, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "3e42aab6-7ce1-45eb-aac4-826a6dfcc78b", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698672.084589 + }, + "3e7efe25-07e3-45da-8e63-6e9ed7c37bed": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698693.766751, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "3e7efe25-07e3-45da-8e63-6e9ed7c37bed", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "waits on ops", + "updated_at": 1794698694.3609998 + }, + "439e0971-097a-43d8-9b40-26bab7fcd3a4": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698694.95162, + "depends_on": [], + "evidence": [ + { + "at": 1794698695.5368562, + "by": "human", + "kind": "manual", + "passed": true, + "ref": "https://example.invalid/log/7" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "439e0971-097a-43d8-9b40-26bab7fcd3a4", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "carries a reference", + "updated_at": 1794698695.5369 + }, + "48612b52-f063-47d1-82b0-f9463462fd09": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698692.575265, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "48612b52-f063-47d1-82b0-f9463462fd09", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "no verification yet", + "updated_at": 1794698692.575265 + }, + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698682.411555, + "depends_on": [], + "evidence": [ + { + "at": 1794698686.957033, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "4dc5d162-1dc5-452c-8ad4-efebc110f4ab", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698686.957033 + }, + "55907557-c8d1-4a3b-8242-c39e85bc24d8": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698690.095215, + "depends_on": [], + "evidence": [ + { + "at": 1794698691.3665679, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + }, + { + "at": 1794698691.984378, + "by": "human", + "kind": "human", + "passed": true, + "ref": "sign-off" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "55907557-c8d1-4a3b-8242-c39e85bc24d8", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "verified by a human", + "updated_at": 1794698691.984438 + }, + "5c7adc0d-d21d-4064-ba3b-32ab946bcc80": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698699.6489332, + "depends_on": [ + "2424fc1b-2463-48ca-8368-561083b6b32a", + "439e0971-097a-43d8-9b40-26bab7fcd3a4" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "5c7adc0d-d21d-4064-ba3b-32ab946bcc80", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after two items", + "updated_at": 1794698699.6489332 + }, + "82af13a6-2af7-4a89-99b5-cb76f17f38d6": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698687.585543, + "depends_on": [], + "evidence": [ + { + "at": 1794698688.848358, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + }, + { + "at": 1794698689.4897459, + "by": "human", + "kind": "manual", + "passed": true, + "ref": "CI ✓ run 42 — grün" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "82af13a6-2af7-4a89-99b5-cb76f17f38d6", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "verified by CI", + "updated_at": 1794698689.4897978 + }, + "926acf3f-8331-4ffc-9878-743004594319": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698698.480046, + "depends_on": [ + "439e0971-097a-43d8-9b40-26bab7fcd3a4" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "926acf3f-8331-4ffc-9878-743004594319", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after a planned item", + "updated_at": 1794698698.480046 + }, + "9d0ec325-02d4-4d12-a45e-60ae52f2df82": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698697.882132, + "depends_on": [ + "2424fc1b-2463-48ca-8368-561083b6b32a" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "9d0ec325-02d4-4d12-a45e-60ae52f2df82", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after the verified item", + "updated_at": 1794698697.882132 + }, + "c7e03b49-63e9-43cb-8812-7e64e3540945": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698674.842975, + "depends_on": [], + "evidence": [ + { + "at": 1794698676.149426, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "backend", + "handoff": "검토: 부호를 확인할 것", + "human_required": false, + "id": "c7e03b49-63e9-43cb-8812-7e64e3540945", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "notes/plan.md", + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "덧셈을 고친다", + "updated_at": 1794698676.149426 + }, + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f": { + "blocked_reason": "quality gate failed: 0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"", + "claimed_at": null, + "created_at": 1794698678.669067, + "depends_on": [], + "evidence": [ + { + "at": 1794698679.930895, + "by": "codex", + "kind": "gate", + "passed": false, + "ref": "0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"" + } + ], + "goal": "", + "handoff": "", + "human_required": true, + "id": "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "codex", + "state": "blocked", + "task": "fix add badly in a pipeline", + "updated_at": 1794698679.930895 + }, + "db0ad772-7a10-587a-b48c-581e726e7b09": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698700.236747, + "depends_on": [], + "evidence": [ + { + "at": 1794698700.236747, + "by": "tracegraph", + "kind": "tracegraph", + "passed": false, + "ref": "sha256:2469307ff4b7bc62fd803a18822f3d26c6620bfaa06e0037db62082f6c9c528b" + } + ], + "goal": "review", + "handoff": "", + "human_required": true, + "id": "db0ad772-7a10-587a-b48c-581e726e7b09", + "inputs": [ + "source:tracegraph.review-candidates@v1", + "run_id:efd16fc1-758e-48fd-a765-bb3e27815952", + "pattern:tool-retry-failure@v2", + "tool_key:syncmill::board_stats", + "artifact_digest:sha256:2469307ff4b7bc62fd803a18822f3d26c6620bfaa06e0037db62082f6c9c528b" + ], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "review", + "task": "Review Tracegraph tool-retry-failure@v2 finding for syncmill::board_stats", + "updated_at": 1794698700.236747 + }, + "db0e439a-57dc-4e10-a956-d0f7b4807781": { + "blocked_reason": "All agents failed:\n [codex] quality gate failed: 0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"", + "claimed_at": null, + "created_at": 1794698676.7810402, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "db0e439a-57dc-4e10-a956-d0f7b4807781", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "none", + "state": "blocked", + "task": "fix add badly", + "updated_at": 1794698678.03695 + }, + "e29da672-99dd-4f00-8256-eb49ac361207": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698696.119448, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "e29da672-99dd-4f00-8256-eb49ac361207", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "needs a person", + "updated_at": 1794698696.119448 + }, + "f5cb4597-7808-46ab-8f59-debe82245705": { + "blocked_reason": "All agents failed:\n [codex] codex (fake): refused", + "claimed_at": null, + "created_at": 1794698680.559537, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "f5cb4597-7808-46ab-8f59-debe82245705", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "none", + "state": "blocked", + "task": "ask a refusing agent", + "updated_at": 1794698681.787213 + } + }, + "order": [ + "3e42aab6-7ce1-45eb-aac4-826a6dfcc78b", + "2424fc1b-2463-48ca-8368-561083b6b32a", + "c7e03b49-63e9-43cb-8812-7e64e3540945", + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705", + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab", + "82af13a6-2af7-4a89-99b5-cb76f17f38d6", + "55907557-c8d1-4a3b-8242-c39e85bc24d8", + "48612b52-f063-47d1-82b0-f9463462fd09", + "3e7efe25-07e3-45da-8e63-6e9ed7c37bed", + "439e0971-097a-43d8-9b40-26bab7fcd3a4", + "e29da672-99dd-4f00-8256-eb49ac361207", + "0b7b1a14-7073-41ad-9a7d-062ee8c0148c", + "9d0ec325-02d4-4d12-a45e-60ae52f2df82", + "926acf3f-8331-4ffc-9878-743004594319", + "0632579b-7a48-4acc-9877-087a27d146bf", + "5c7adc0d-d21d-4064-ba3b-32ab946bcc80", + "db0ad772-7a10-587a-b48c-581e726e7b09" + ], + "stats": { + "aged": { + "blocked_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705", + "3e7efe25-07e3-45da-8e63-6e9ed7c37bed" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "c7e03b49-63e9-43cb-8812-7e64e3540945" + ], + "false_done": [], + "human_required_aged": [ + "db0e439a-57dc-4e10-a956-d0f7b4807781", + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f", + "f5cb4597-7808-46ab-8f59-debe82245705", + "e29da672-99dd-4f00-8256-eb49ac361207", + "db0ad772-7a10-587a-b48c-581e726e7b09" + ], + "reclaimed_stale": 1, + "redispatched": [ + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab" + ], + "stall_seconds": 3600, + "total": 19 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 1, + "redispatched": [ + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab" + ], + "stall_seconds": 3600, + "total": 19 + } + }, + "transitions": { + "0632579b-7a48-4acc-9877-087a27d146bf": [ + { + "actor": "human", + "at": 1794698699.065164, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "0b7b1a14-7073-41ad-9a7d-062ee8c0148c": [ + { + "actor": "human", + "at": 1794698696.702538, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698697.2933462, + "from_state": "planned", + "note": "annotated", + "to_state": "planned" + } + ], + "2424fc1b-2463-48ca-8368-561083b6b32a": [ + { + "actor": "human", + "at": 1794698672.8998332, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "69236332-c7b0-4fec-8031-7bef465c20d0", + "at": 1794698673.585401, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698674.222513, + "from_state": "running", + "note": "agent completed; verified", + "to_state": "done" + } + ], + "3e42aab6-7ce1-45eb-aac4-826a6dfcc78b": [ + { + "actor": "human", + "at": 1794698670.41087, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "7c6848c4-0788-4532-9fd5-22fcba8511e5", + "at": 1794698671.138468, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698672.084589, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "3e7efe25-07e3-45da-8e63-6e9ed7c37bed": [ + { + "actor": "human", + "at": 1794698693.766751, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698694.3609998, + "from_state": "planned", + "note": "waiting on ops", + "to_state": "blocked" + } + ], + "439e0971-097a-43d8-9b40-26bab7fcd3a4": [ + { + "actor": "human", + "at": 1794698694.95162, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698695.5369, + "from_state": "planned", + "note": "annotated", + "to_state": "planned" + } + ], + "48612b52-f063-47d1-82b0-f9463462fd09": [ + { + "actor": "human", + "at": 1794698692.575265, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "4dc5d162-1dc5-452c-8ad4-efebc110f4ab": [ + { + "actor": "human", + "at": 1794698682.411555, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "07f2e02c-a5c6-43c2-b60e-352c910540a7", + "at": 1794698683.05756, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698686.332617, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "3a9d8230-7135-4a49-abb0-5eb470cf5813", + "at": 1794698686.3330638, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698686.957033, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "55907557-c8d1-4a3b-8242-c39e85bc24d8": [ + { + "actor": "human", + "at": 1794698690.095215, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "78531eea-b3d4-408b-898f-03f77b526188", + "at": 1794698690.738274, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698691.3665679, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + }, + { + "actor": "human", + "at": 1794698691.984438, + "from_state": "review", + "note": "", + "to_state": "done" + } + ], + "5c7adc0d-d21d-4064-ba3b-32ab946bcc80": [ + { + "actor": "human", + "at": 1794698699.6489332, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "82af13a6-2af7-4a89-99b5-cb76f17f38d6": [ + { + "actor": "human", + "at": 1794698687.585543, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "1d2fe260-f7bf-4d48-b56b-32095d82b0f0", + "at": 1794698688.226159, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698688.848358, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + }, + { + "actor": "human", + "at": 1794698689.4897978, + "from_state": "review", + "note": "", + "to_state": "done" + } + ], + "926acf3f-8331-4ffc-9878-743004594319": [ + { + "actor": "human", + "at": 1794698698.480046, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "9d0ec325-02d4-4d12-a45e-60ae52f2df82": [ + { + "actor": "human", + "at": 1794698697.882132, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "c7e03b49-63e9-43cb-8812-7e64e3540945": [ + { + "actor": "human", + "at": 1794698674.842975, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "05d4da4c-9c6d-41df-aa86-f5fbe03aaed7", + "at": 1794698675.4951308, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698676.149426, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "d3eb1d37-c360-4e72-8ec7-6198f513ba8f": [ + { + "actor": "human", + "at": 1794698678.669067, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "8cb9d4e1-44fb-45e4-ae94-367dd66efc3e", + "at": 1794698679.3364139, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698679.930895, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "db0ad772-7a10-587a-b48c-581e726e7b09": [ + { + "actor": "tracegraph-import", + "at": 1794698700.236747, + "from_state": null, + "note": "imported review candidate", + "to_state": "review" + } + ], + "db0e439a-57dc-4e10-a956-d0f7b4807781": [ + { + "actor": "human", + "at": 1794698676.7810402, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "5a85a64e-3158-4cbb-98b3-b4a4fe729ab5", + "at": 1794698677.4456031, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "none", + "at": 1794698678.03695, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "e29da672-99dd-4f00-8256-eb49ac361207": [ + { + "actor": "human", + "at": 1794698696.119448, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "f5cb4597-7808-46ab-8f59-debe82245705": [ + { + "actor": "human", + "at": 1794698680.559537, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "f2fbb500-b702-4d18-9b4c-969b7cbad0f9", + "at": 1794698681.226685, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "none", + "at": 1794698681.787213, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ] + } + } + }, + "running": { + "decisions": {}, + "files": [ + "board.db", + "board.db-shm", + "board.db-wal" + ], + "frozen_at": 1794698705.2356749, + "items": { + "killed": "0a33e021-c123-47a2-ae88-1b7833bddc36", + "waiting": "31846270-93c4-4261-8808-ecf9247cda34" + }, + "release_read": { + "active_decisions": { + "*": [], + "backend": [] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "0a33e021-c123-47a2-ae88-1b7833bddc36": { + "blocked_reason": "", + "claimed_at": 1794698705.2356749, + "created_at": 1794698704.587973, + "depends_on": [], + "evidence": [], + "goal": "backend", + "handoff": "", + "human_required": false, + "id": "0a33e021-c123-47a2-ae88-1b7833bddc36", + "inputs": [], + "lease_run_id": "c8b5aa92-62d3-4de0-ba79-b61b15e23f53", + "outputs": [], + "owner_agent": null, + "state": "running", + "task": "killed mid-run", + "updated_at": 1794698705.2356749 + }, + "31846270-93c4-4261-8808-ecf9247cda34": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698704.0078442, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "31846270-93c4-4261-8808-ecf9247cda34", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "still planned", + "updated_at": 1794698704.0078442 + } + }, + "order": [ + "31846270-93c4-4261-8808-ecf9247cda34", + "0a33e021-c123-47a2-ae88-1b7833bddc36" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "planned": 1, + "running": 1 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "planned": 1, + "running": 1 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "transitions": { + "0a33e021-c123-47a2-ae88-1b7833bddc36": [ + { + "actor": "human", + "at": 1794698704.587973, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "c8b5aa92-62d3-4de0-ba79-b61b15e23f53", + "at": 1794698705.2356749, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + } + ], + "31846270-93c4-4261-8808-ecf9247cda34": [ + { + "actor": "human", + "at": 1794698704.0078442, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ] + } + } + } + }, + "stall_seconds": 3600, + "tracegraph_report": "tests/fixtures/tracegraph/v1.json" +} diff --git a/tests/fixtures/persisted/board/v0.2.0/compacted/board.db b/tests/fixtures/persisted/board/v0.2.0/compacted/board.db new file mode 100644 index 0000000000000000000000000000000000000000..ad7b20b16da09f9121a7f05c732f42f32081fae2 GIT binary patch literal 98304 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.2.0/lifecycle/board.db b/tests/fixtures/persisted/board/v0.2.0/lifecycle/board.db new file mode 100644 index 0000000000000000000000000000000000000000..adea925973ea1ab73daa9596ba3917a5b6082ee5 GIT binary patch literal 106496 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 literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.2.0/running/board.db-shm b/tests/fixtures/persisted/board/v0.2.0/running/board.db-shm new file mode 100644 index 0000000000000000000000000000000000000000..c6e875f0a57d520af9e7c5e1bbc301ef749aecba GIT binary patch literal 32768 zcmeI*Pf9{j6bIleE$t6QI(Y8DNl=?;mMaj1a1kxXkppoNu0?2EJJ549!jaH0&i8{K z_wjh|!ub|(Z?kzi%d`%CxQVrizJIL0)-Q|k?DKos9==Xi_s`SObpF=-@%z|npWJtQ zl%LnX%XvJtqgT;h^g5dV+(z%BkI{Z~5ETLh2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72>f?} zJo7~e5FkLHmO!4jB?Jf%AV7csff@oAHO4e00RjXF90}wJ(?X!8K&R%|rX~;qmlOz; z707!vgg{M!Zq2bxO@IIa0t5&UAV7cs0Rkli@*Y(oP*Wgp5EcS81@i7}AwYn@DS;h7 Cuq6`! literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.2.0/running/board.db-wal b/tests/fixtures/persisted/board/v0.2.0/running/board.db-wal new file mode 100644 index 0000000000000000000000000000000000000000..2514dfa752dd9b26065866b461d2b51c788798c5 GIT binary patch literal 45352 zcmeI*PiP!f9Ki86GaENayFNFySQ(H&(bSfaote$<1W#U!717f`(R!Gjnbft(D9M(3 z5L(3+^iV_#o{D&h;z8*}OGN3xo;-;3U{er8&?>Z48Y~qn`d)TsRRkFiJ#6xQ`)An6 z%-i?-%qhQpzc=k8x4kT!?{)}rhtMtg{^$2AcR#%U$k#s}J~^^Fsdkxv-~aiUn>(+a zSox%;{~$+%Jf+@f2q1s}0tg_000IagfB*srY-E9#wwv|PzTX!0dc8JUtB2KUwGsJ# z+VET_c0J!|wjEFQ|#GwWsto_f0f zh=a~_6wP=}%S%*0N!oBaQG3SewA_w6oqGP&mQbOvHh|2?Y-|jS$vL+dRUtp z3`>Y=)pvtt%WF5B89#11O|RuTLC^@CG@hIBn(a7={N_?m4QTTD`6$cMB;ORnS?^jL zJyvYhWv%E-TjUFNKf3bKTc>uvF|PKR@+TpGQExN^5I_I{1Q0*~0R#|0009IL7;b?r zmTlxI3v=AE$MSrE3aY9DEAj%b?@gx;|8{A%pBFeUUl;eAHb?lcF$S)>L07?7RNg*FAG+ zArskdeRU; z009ILKmY**5I_I{1Q0-AV+csY+G+F_qim_$>pqt)St_h8I<%sWVDf>>r)z7K_jIzr zlE;PoP#%{T^bs@!5I_I{1Q0*~0R#|0009ILxHSTL>VKJq4z02Wnp0LdR%R-Jif5~i zsmKd_)xBr>S@(mfeqJEa_apdHCbuSPdPM*M1Q0*~0R#|0009ILKwvWn1S6_a!T4tp zLa8i(J0ku%vCJ7}L!VKsDOfTupi2e@d4X5oz5eZ<>*=TcyudjjugFz-ZZljZVnhG| z1Q0*~0R#|0009ILKwwA(wpHxG%?9!n4XpKjc`hPfoWPt=#}!F~e4mPVLPuT97Z{Hx zn)}ZjeX+m3z_O6bLu$gX5kLR|1Q0*~0R#|0009IL*f0Y7jL|S$zn@^4#SY8NEGSk& zR7Be}Q;`>#d*!unet6{flX|{@p%xZkZ2_%ALjVB;5I_I{1Q0*~0R#|0V7LVI`T}Kg z2r8;O)oVwQ7r1)%h0f#4?%94`U`@!i;fkBlB7gt_2q1s}0tg_000IagfWUtWY^{ju ISTSGVPu;qr{r~^~ literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.3.0/bindings.json b/tests/fixtures/persisted/board/v0.3.0/bindings.json new file mode 100644 index 0000000..aacaea7 --- /dev/null +++ b/tests/fixtures/persisted/board/v0.3.0/bindings.json @@ -0,0 +1,2015 @@ +{ + "box_root": "/private/var/folders/4n/mt3km5rs1bn_b0w_d6hvlmhc0000gn/T/tmpwi711q0i", + "missing_dependency": "00000000-0000-4000-8000-000000000000", + "release": "0.3.0", + "scenarios": { + "compacted": { + "before_compaction": { + "active_decisions": { + "*": [] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "decision_rows": [], + "decisions_mapped": [], + "frozen_at": 1794698781.3185, + "items": { + "554d0700-3c52-42e8-a072-ac29dd9e1eb2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698780.0333068, + "depends_on": [], + "evidence": [ + { + "at": 1794698781.3185, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "554d0700-3c52-42e8-a072-ac29dd9e1eb2", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698781.3185 + }, + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698765.559068, + "depends_on": [], + "evidence": [ + { + "at": 1794698770.206312, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698770.206312 + }, + "8a6070da-67d6-491d-92ca-5c1801d526c2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698770.8670259, + "depends_on": [], + "evidence": [ + { + "at": 1794698779.412703, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "8a6070da-67d6-491d-92ca-5c1801d526c2", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a later crash", + "updated_at": 1794698779.412703 + } + }, + "order": [ + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "8a6070da-67d6-491d-92ca-5c1801d526c2", + "554d0700-3c52-42e8-a072-ac29dd9e1eb2" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "8a6070da-67d6-491d-92ca-5c1801d526c2" + ], + "stall_seconds": 3600, + "total": 3 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "8a6070da-67d6-491d-92ca-5c1801d526c2" + ], + "stall_seconds": 3600, + "total": 3 + } + }, + "transitions": { + "554d0700-3c52-42e8-a072-ac29dd9e1eb2": [ + { + "actor": "human", + "at": 1794698780.0333068, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "369e5972-3979-4d58-b1cd-82a3e882878b", + "at": 1794698780.7056189, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698781.3185, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac": [ + { + "actor": "human", + "at": 1794698765.559068, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "43ce6bc3-fef6-4bf8-9d80-a77f30c11a90", + "at": 1794698766.225875, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698769.50398, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "e29927c4-093e-4aa3-91b2-c4ed8c4cf0e5", + "at": 1794698769.504431, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698770.206312, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "8a6070da-67d6-491d-92ca-5c1801d526c2": [ + { + "actor": "human", + "at": 1794698770.8670259, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "e13e94f2-8616-442a-acb3-3041d8a6c42f", + "at": 1794698771.513713, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698778.778651, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "d471aa02-a69f-4a07-a622-65a46dcdbd81", + "at": 1794698778.7790341, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698779.412703, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ] + } + }, + "decisions": {}, + "files": [ + "board.db", + "board.db.gc-lock" + ], + "frozen_at": 1794698781.3185, + "items": { + "mixed": "8a6070da-67d6-491d-92ca-5c1801d526c2", + "passed": "554d0700-3c52-42e8-a072-ac29dd9e1eb2", + "rolled": "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac" + }, + "release_read": { + "active_decisions": { + "*": [] + }, + "aggregates": { + "transition_counters": [ + { + "name": "reclaimed_stale", + "value": 1 + } + ], + "transition_rollups": [ + { + "claim_count": 2, + "item_id": "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac" + }, + { + "claim_count": 1, + "item_id": "8a6070da-67d6-491d-92ca-5c1801d526c2" + } + ] + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "554d0700-3c52-42e8-a072-ac29dd9e1eb2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698780.0333068, + "depends_on": [], + "evidence": [ + { + "at": 1794698781.3185, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "554d0700-3c52-42e8-a072-ac29dd9e1eb2", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698781.3185 + }, + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698765.559068, + "depends_on": [], + "evidence": [ + { + "at": 1794698770.206312, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698770.206312 + }, + "8a6070da-67d6-491d-92ca-5c1801d526c2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698770.8670259, + "depends_on": [], + "evidence": [ + { + "at": 1794698779.412703, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "8a6070da-67d6-491d-92ca-5c1801d526c2", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a later crash", + "updated_at": 1794698779.412703 + } + }, + "order": [ + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "8a6070da-67d6-491d-92ca-5c1801d526c2", + "554d0700-3c52-42e8-a072-ac29dd9e1eb2" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "8a6070da-67d6-491d-92ca-5c1801d526c2" + ], + "stall_seconds": 3600, + "total": 3 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "review": 3 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 2, + "redispatched": [ + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac", + "8a6070da-67d6-491d-92ca-5c1801d526c2" + ], + "stall_seconds": 3600, + "total": 3 + } + }, + "transitions": { + "554d0700-3c52-42e8-a072-ac29dd9e1eb2": [ + { + "actor": "human", + "at": 1794698780.0333068, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "369e5972-3979-4d58-b1cd-82a3e882878b", + "at": 1794698780.7056189, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698781.3185, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "5aa259d1-6f23-41ae-8ba2-87d2ec71c8ac": [], + "8a6070da-67d6-491d-92ca-5c1801d526c2": [ + { + "actor": "system", + "at": 1794698778.778651, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "d471aa02-a69f-4a07-a622-65a46dcdbd81", + "at": 1794698778.7790341, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698779.412703, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ] + } + } + }, + "crash-blocked": { + "decisions": {}, + "files": [ + "board.db" + ], + "frozen_at": 1794698764.732039, + "items": { + "crashed": "9528575c-aedb-4c2e-ae84-361dc144bc53", + "interrupted": "42561466-5838-4697-b299-2ffff69e64f5" + }, + "release_read": { + "active_decisions": { + "*": [] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "boundary": { + "item": "9528575c-aedb-4c2e-ae84-361dc144bc53", + "stats": { + "after": { + "blocked_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "at": { + "blocked_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "before": { + "blocked_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "times": { + "after": 1794702364.7320392, + "at": 1794702364.732039, + "before": 1794702364.7320387 + } + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "42561466-5838-4697-b299-2ffff69e64f5": { + "blocked_reason": "orchestration cancelled by operator (SIGINT)", + "claimed_at": null, + "created_at": 1794698762.1561542, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "42561466-5838-4697-b299-2ffff69e64f5", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "interrupted by the operator", + "updated_at": 1794698763.438907 + }, + "9528575c-aedb-4c2e-ae84-361dc144bc53": { + "blocked_reason": "orchestration crashed: RuntimeError: frozen: injected orchestration failure", + "claimed_at": null, + "created_at": 1794698764.075649, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "9528575c-aedb-4c2e-ae84-361dc144bc53", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "orchestration raises", + "updated_at": 1794698764.732039 + } + }, + "order": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "stats": { + "aged": { + "blocked_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [ + "42561466-5838-4697-b299-2ffff69e64f5", + "9528575c-aedb-4c2e-ae84-361dc144bc53" + ], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "blocked": 2 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "transitions": { + "42561466-5838-4697-b299-2ffff69e64f5": [ + { + "actor": "human", + "at": 1794698762.1561542, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "374d6c22-7066-4aa2-bd96-359fbbf30ce7", + "at": 1794698762.819686, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698763.438907, + "from_state": "running", + "note": "orchestration cancelled by operator (SIGINT)", + "to_state": "blocked" + } + ], + "9528575c-aedb-4c2e-ae84-361dc144bc53": [ + { + "actor": "human", + "at": 1794698764.075649, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "4e313a33-e7ec-4d22-bb27-b930c1c1bd5a", + "at": 1794698764.7313511, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698764.732039, + "from_state": "running", + "note": "orchestration crashed: RuntimeError: frozen: injected orchestration failure", + "to_state": "blocked" + } + ] + } + } + }, + "lifecycle": { + "decisions": { + "global": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "other-scope": "92c803c3-bbd9-434d-92f5-9b1992bde19b", + "replacement": "508e80a7-b951-453d-8810-9b3e202c3902", + "scoped": "06ef68ec-d3e5-42e9-a0d9-b410bb4f2010", + "superseded": "41153f56-9772-4a98-af8e-e07449e72429" + }, + "files": [ + "board.db", + "board.db.gc-lock" + ], + "frozen_at": 1794698758.615681, + "items": { + "agent-failed": "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "annotated": "2bf84561-3100-43b4-b18b-6852c5e6fdf4", + "bare-done-refused": "50e5fd9f-b290-4669-8b50-adaddfb77666", + "evidence-done": "7d718991-93a0-4810-9974-4b03f991f49f", + "handed-off": "734659f1-2efe-4ea5-a1ee-61fc28833f96", + "human-blocked": "fb625361-3bb5-41f1-a3a2-35776a5d5ad2", + "human-cleared": "f305a5e1-4109-48ed-b7dd-45776391f3de", + "human-required": "9881d72d-cabb-42cb-bb76-4a80fb5215ff", + "imported-1": "db0ad772-7a10-587a-b48c-581e726e7b09", + "needs-done": "641a64eb-9490-47d8-83fc-976bf44cbfc2", + "needs-missing": "42cab35d-4f16-46f6-8b0f-73c2a0bfc454", + "needs-planned": "25bb4bc9-655b-4720-9ec5-4532b156662c", + "needs-two": "a741aa62-b45b-42cb-ad67-3aee1100c050", + "passed": "806b4c98-9f90-4b58-bf0d-74b3639c2661", + "pipeline-gate-failed": "f4187a31-3f44-420a-99cf-9e76a6889012", + "reclaimed": "634c75c2-f4ab-4094-a040-9b7ffb7c994d", + "route-gate-failed": "959998b8-6833-4792-9a93-acc84c8b4c4e", + "signed-off": "86165555-70ea-4b47-818f-f448c51c3f84", + "verified": "b2475413-f713-4306-bf87-c9400e1c3066" + }, + "release_read": { + "active_decisions": { + "*": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698756.838748, + "id": "06ef68ec-d3e5-42e9-a0d9-b410bb4f2010", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698758.615681, + "id": "92c803c3-bbd9-434d-92f5-9b1992bde19b", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "backend": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698756.838748, + "id": "06ef68ec-d3e5-42e9-a0d9-b410bb4f2010", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ], + "docs": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698758.615681, + "id": "92c803c3-bbd9-434d-92f5-9b1992bde19b", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "nothing": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ], + "review": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + } + ] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "boundary": { + "item": "fb625361-3bb5-41f1-a3a2-35776a5d5ad2", + "stats": { + "after": { + "blocked_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "fb625361-3bb5-41f1-a3a2-35776a5d5ad2" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "734659f1-2efe-4ea5-a1ee-61fc28833f96" + ], + "false_done": [], + "human_required_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9" + ], + "reclaimed_stale": 1, + "redispatched": [ + "634c75c2-f4ab-4094-a040-9b7ffb7c994d" + ], + "stall_seconds": 3600, + "total": 19 + }, + "at": { + "blocked_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "fb625361-3bb5-41f1-a3a2-35776a5d5ad2" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "734659f1-2efe-4ea5-a1ee-61fc28833f96" + ], + "false_done": [], + "human_required_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9" + ], + "reclaimed_stale": 1, + "redispatched": [ + "634c75c2-f4ab-4094-a040-9b7ffb7c994d" + ], + "stall_seconds": 3600, + "total": 19 + }, + "before": { + "blocked_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "734659f1-2efe-4ea5-a1ee-61fc28833f96" + ], + "false_done": [], + "human_required_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9" + ], + "reclaimed_stale": 1, + "redispatched": [ + "634c75c2-f4ab-4094-a040-9b7ffb7c994d" + ], + "stall_seconds": 3600, + "total": 19 + } + }, + "times": { + "after": 1794702349.717631, + "at": 1794702349.7176309, + "before": 1794702349.7176306 + } + }, + "decision_rows": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698756.838748, + "id": "06ef68ec-d3e5-42e9-a0d9-b410bb4f2010", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698757.4252732, + "id": "41153f56-9772-4a98-af8e-e07449e72429", + "scope": "", + "superseded_at": 1794698758.017269, + "superseded_by": "508e80a7-b951-453d-8810-9b3e202c3902", + "text": "Tabs, not spaces." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698758.615681, + "id": "92c803c3-bbd9-434d-92f5-9b1992bde19b", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "decisions_mapped": [ + { + "created_at": 1794698756.241415, + "id": "d62074be-bae5-4602-b56f-fb3d05a350d8", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Use uv for every Python command." + }, + { + "created_at": 1794698756.838748, + "id": "06ef68ec-d3e5-42e9-a0d9-b410bb4f2010", + "scope": "backend", + "superseded_at": null, + "superseded_by": null, + "text": "백엔드는 SQLite를 유지한다." + }, + { + "created_at": 1794698757.4252732, + "id": "41153f56-9772-4a98-af8e-e07449e72429", + "scope": "", + "superseded_at": 1794698758.017269, + "superseded_by": "508e80a7-b951-453d-8810-9b3e202c3902", + "text": "Tabs, not spaces." + }, + { + "created_at": 1794698758.017269, + "id": "508e80a7-b951-453d-8810-9b3e202c3902", + "scope": "", + "superseded_at": null, + "superseded_by": null, + "text": "Spaces, not tabs." + }, + { + "created_at": 1794698758.615681, + "id": "92c803c3-bbd9-434d-92f5-9b1992bde19b", + "scope": "docs", + "superseded_at": null, + "superseded_by": null, + "text": "Ship the docs with the code." + } + ], + "items": { + "25bb4bc9-655b-4720-9ec5-4532b156662c": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698753.872281, + "depends_on": [ + "2bf84561-3100-43b4-b18b-6852c5e6fdf4" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "25bb4bc9-655b-4720-9ec5-4532b156662c", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after a planned item", + "updated_at": 1794698753.872281 + }, + "2bf84561-3100-43b4-b18b-6852c5e6fdf4": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698750.316517, + "depends_on": [], + "evidence": [ + { + "at": 1794698750.9170392, + "by": "human", + "kind": "manual", + "passed": true, + "ref": "https://example.invalid/log/7" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "2bf84561-3100-43b4-b18b-6852c5e6fdf4", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "carries a reference", + "updated_at": 1794698750.917084 + }, + "42cab35d-4f16-46f6-8b0f-73c2a0bfc454": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698754.470057, + "depends_on": [ + "00000000-0000-4000-8000-000000000000" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "42cab35d-4f16-46f6-8b0f-73c2a0bfc454", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after an item that does not exist", + "updated_at": 1794698754.470057 + }, + "50e5fd9f-b290-4669-8b50-adaddfb77666": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698747.9179049, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "50e5fd9f-b290-4669-8b50-adaddfb77666", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "no verification yet", + "updated_at": 1794698747.9179049 + }, + "634c75c2-f4ab-4094-a040-9b7ffb7c994d": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698737.9575748, + "depends_on": [], + "evidence": [ + { + "at": 1794698742.361517, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "634c75c2-f4ab-4094-a040-9b7ffb7c994d", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add after a crash", + "updated_at": 1794698742.361517 + }, + "641a64eb-9490-47d8-83fc-976bf44cbfc2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698753.2922099, + "depends_on": [ + "b2475413-f713-4306-bf87-c9400e1c3066" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "641a64eb-9490-47d8-83fc-976bf44cbfc2", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after the verified item", + "updated_at": 1794698753.2922099 + }, + "734659f1-2efe-4ea5-a1ee-61fc28833f96": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698730.772115, + "depends_on": [], + "evidence": [ + { + "at": 1794698732.008031, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "backend", + "handoff": "검토: 부호를 확인할 것", + "human_required": false, + "id": "734659f1-2efe-4ea5-a1ee-61fc28833f96", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "notes/plan.md", + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "덧셈을 고친다", + "updated_at": 1794698732.008031 + }, + "7d718991-93a0-4810-9974-4b03f991f49f": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698742.971026, + "depends_on": [], + "evidence": [ + { + "at": 1794698744.230538, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + }, + { + "at": 1794698744.849049, + "by": "human", + "kind": "manual", + "passed": true, + "ref": "CI ✓ run 42 — grün" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "7d718991-93a0-4810-9974-4b03f991f49f", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "verified by CI", + "updated_at": 1794698744.849101 + }, + "806b4c98-9f90-4b58-bf0d-74b3639c2661": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698726.8066401, + "depends_on": [], + "evidence": [ + { + "at": 1794698728.3508952, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "806b4c98-9f90-4b58-bf0d-74b3639c2661", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "review", + "task": "fix add", + "updated_at": 1794698728.3508952 + }, + "86165555-70ea-4b47-818f-f448c51c3f84": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698745.4488971, + "depends_on": [], + "evidence": [ + { + "at": 1794698746.7029939, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + }, + { + "at": 1794698747.319458, + "by": "human", + "kind": "human", + "passed": true, + "ref": "sign-off" + } + ], + "goal": "", + "handoff": "", + "human_required": false, + "id": "86165555-70ea-4b47-818f-f448c51c3f84", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "verified by a human", + "updated_at": 1794698747.3195179 + }, + "959998b8-6833-4792-9a93-acc84c8b4c4e": { + "blocked_reason": "All agents failed:\n [codex] quality gate failed: 0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"", + "claimed_at": null, + "created_at": 1794698732.623751, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "959998b8-6833-4792-9a93-acc84c8b4c4e", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "none", + "state": "blocked", + "task": "fix add badly", + "updated_at": 1794698733.833706 + }, + "9881d72d-cabb-42cb-bb76-4a80fb5215ff": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698751.5166779, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "9881d72d-cabb-42cb-bb76-4a80fb5215ff", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "needs a person", + "updated_at": 1794698751.5166779 + }, + "a741aa62-b45b-42cb-ad67-3aee1100c050": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698755.069921, + "depends_on": [ + "b2475413-f713-4306-bf87-c9400e1c3066", + "2bf84561-3100-43b4-b18b-6852c5e6fdf4" + ], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "a741aa62-b45b-42cb-ad67-3aee1100c050", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "after two items", + "updated_at": 1794698755.069921 + }, + "b2475413-f713-4306-bf87-c9400e1c3066": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698728.955035, + "depends_on": [], + "evidence": [ + { + "at": 1794698730.181229, + "by": "codex", + "kind": "gate", + "passed": true, + "ref": "1/1 checks passed" + } + ], + "goal": "backend", + "handoff": "", + "human_required": false, + "id": "b2475413-f713-4306-bf87-c9400e1c3066", + "inputs": [], + "lease_run_id": null, + "outputs": [ + "calc.py" + ], + "owner_agent": "codex", + "state": "done", + "task": "fix add and finish", + "updated_at": 1794698730.181229 + }, + "db0ad772-7a10-587a-b48c-581e726e7b09": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698755.65433, + "depends_on": [], + "evidence": [ + { + "at": 1794698755.65433, + "by": "tracegraph", + "kind": "tracegraph", + "passed": false, + "ref": "sha256:2469307ff4b7bc62fd803a18822f3d26c6620bfaa06e0037db62082f6c9c528b" + } + ], + "goal": "review", + "handoff": "", + "human_required": true, + "id": "db0ad772-7a10-587a-b48c-581e726e7b09", + "inputs": [ + "source:tracegraph.review-candidates@v1", + "run_id:efd16fc1-758e-48fd-a765-bb3e27815952", + "pattern:tool-retry-failure@v2", + "tool_key:syncmill::board_stats", + "artifact_digest:sha256:2469307ff4b7bc62fd803a18822f3d26c6620bfaa06e0037db62082f6c9c528b" + ], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "review", + "task": "Review Tracegraph tool-retry-failure@v2 finding for syncmill::board_stats", + "updated_at": 1794698755.65433 + }, + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9": { + "blocked_reason": "All agents failed:\n [codex] codex (fake): refused", + "claimed_at": null, + "created_at": 1794698736.2164521, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": true, + "id": "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "none", + "state": "blocked", + "task": "ask a refusing agent", + "updated_at": 1794698737.354914 + }, + "f305a5e1-4109-48ed-b7dd-45776391f3de": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698752.109395, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "f305a5e1-4109-48ed-b7dd-45776391f3de", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "needed a person", + "updated_at": 1794698752.705991 + }, + "f4187a31-3f44-420a-99cf-9e76a6889012": { + "blocked_reason": "quality gate failed: 0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"", + "claimed_at": null, + "created_at": 1794698734.4337862, + "depends_on": [], + "evidence": [ + { + "at": 1794698735.610032, + "by": "codex", + "kind": "gate", + "passed": false, + "ref": "0/1 checks passed; failed: python -c \"from calc import add; assert add(2, 3) == 5\"" + } + ], + "goal": "", + "handoff": "", + "human_required": true, + "id": "f4187a31-3f44-420a-99cf-9e76a6889012", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": "codex", + "state": "blocked", + "task": "fix add badly in a pipeline", + "updated_at": 1794698735.610032 + }, + "fb625361-3bb5-41f1-a3a2-35776a5d5ad2": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698749.121001, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "fb625361-3bb5-41f1-a3a2-35776a5d5ad2", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "blocked", + "task": "waits on ops", + "updated_at": 1794698749.7176309 + } + }, + "order": [ + "806b4c98-9f90-4b58-bf0d-74b3639c2661", + "b2475413-f713-4306-bf87-c9400e1c3066", + "734659f1-2efe-4ea5-a1ee-61fc28833f96", + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "634c75c2-f4ab-4094-a040-9b7ffb7c994d", + "7d718991-93a0-4810-9974-4b03f991f49f", + "86165555-70ea-4b47-818f-f448c51c3f84", + "50e5fd9f-b290-4669-8b50-adaddfb77666", + "fb625361-3bb5-41f1-a3a2-35776a5d5ad2", + "2bf84561-3100-43b4-b18b-6852c5e6fdf4", + "9881d72d-cabb-42cb-bb76-4a80fb5215ff", + "f305a5e1-4109-48ed-b7dd-45776391f3de", + "641a64eb-9490-47d8-83fc-976bf44cbfc2", + "25bb4bc9-655b-4720-9ec5-4532b156662c", + "42cab35d-4f16-46f6-8b0f-73c2a0bfc454", + "a741aa62-b45b-42cb-ad67-3aee1100c050", + "db0ad772-7a10-587a-b48c-581e726e7b09" + ], + "stats": { + "aged": { + "blocked_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "fb625361-3bb5-41f1-a3a2-35776a5d5ad2" + ], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [ + "734659f1-2efe-4ea5-a1ee-61fc28833f96" + ], + "false_done": [], + "human_required_aged": [ + "959998b8-6833-4792-9a93-acc84c8b4c4e", + "f4187a31-3f44-420a-99cf-9e76a6889012", + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9", + "9881d72d-cabb-42cb-bb76-4a80fb5215ff", + "db0ad772-7a10-587a-b48c-581e726e7b09" + ], + "reclaimed_stale": 1, + "redispatched": [ + "634c75c2-f4ab-4094-a040-9b7ffb7c994d" + ], + "stall_seconds": 3600, + "total": 19 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "blocked": 4, + "done": 3, + "planned": 8, + "review": 4 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 1, + "redispatched": [ + "634c75c2-f4ab-4094-a040-9b7ffb7c994d" + ], + "stall_seconds": 3600, + "total": 19 + } + }, + "transitions": { + "25bb4bc9-655b-4720-9ec5-4532b156662c": [ + { + "actor": "human", + "at": 1794698753.872281, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "2bf84561-3100-43b4-b18b-6852c5e6fdf4": [ + { + "actor": "human", + "at": 1794698750.316517, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698750.917084, + "from_state": "planned", + "note": "annotated", + "to_state": "planned" + } + ], + "42cab35d-4f16-46f6-8b0f-73c2a0bfc454": [ + { + "actor": "human", + "at": 1794698754.470057, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "50e5fd9f-b290-4669-8b50-adaddfb77666": [ + { + "actor": "human", + "at": 1794698747.9179049, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "634c75c2-f4ab-4094-a040-9b7ffb7c994d": [ + { + "actor": "human", + "at": 1794698737.9575748, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "4d739a5c-490b-47ee-9b92-7595217ac71f", + "at": 1794698738.6025841, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "system", + "at": 1794698741.758962, + "from_state": "running", + "note": "stale-claim recovery", + "to_state": "planned" + }, + { + "actor": "f932738a-73d7-481a-9e78-eee1d7f1ba0b", + "at": 1794698741.759357, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698742.361517, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "641a64eb-9490-47d8-83fc-976bf44cbfc2": [ + { + "actor": "human", + "at": 1794698753.2922099, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "734659f1-2efe-4ea5-a1ee-61fc28833f96": [ + { + "actor": "human", + "at": 1794698730.772115, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "a52224e5-c34e-4b0e-846e-dbd34035fdee", + "at": 1794698731.4154382, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698732.008031, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "7d718991-93a0-4810-9974-4b03f991f49f": [ + { + "actor": "human", + "at": 1794698742.971026, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "e2339bf3-419c-4014-a74c-3e2b3e3770b9", + "at": 1794698743.612858, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698744.230538, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + }, + { + "actor": "human", + "at": 1794698744.849101, + "from_state": "review", + "note": "", + "to_state": "done" + } + ], + "806b4c98-9f90-4b58-bf0d-74b3639c2661": [ + { + "actor": "human", + "at": 1794698726.8066401, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "040d295d-c8bf-4bfa-ac1f-cdfc1c18aa9f", + "at": 1794698727.45507, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698728.3508952, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + } + ], + "86165555-70ea-4b47-818f-f448c51c3f84": [ + { + "actor": "human", + "at": 1794698745.4488971, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "990e4d11-f723-477a-a58c-21b3b4dd378e", + "at": 1794698746.101783, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698746.7029939, + "from_state": "running", + "note": "agent completed; awaiting review", + "to_state": "review" + }, + { + "actor": "human", + "at": 1794698747.3195179, + "from_state": "review", + "note": "", + "to_state": "done" + } + ], + "959998b8-6833-4792-9a93-acc84c8b4c4e": [ + { + "actor": "human", + "at": 1794698732.623751, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "eff407ff-7ed0-4096-8912-b68c456aae5e", + "at": 1794698733.26769, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "none", + "at": 1794698733.833706, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "9881d72d-cabb-42cb-bb76-4a80fb5215ff": [ + { + "actor": "human", + "at": 1794698751.5166779, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "a741aa62-b45b-42cb-ad67-3aee1100c050": [ + { + "actor": "human", + "at": 1794698755.069921, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ], + "b2475413-f713-4306-bf87-c9400e1c3066": [ + { + "actor": "human", + "at": 1794698728.955035, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "8f77b081-6f04-4b50-bce3-df2d7541517a", + "at": 1794698729.589066, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698730.181229, + "from_state": "running", + "note": "agent completed; verified", + "to_state": "done" + } + ], + "db0ad772-7a10-587a-b48c-581e726e7b09": [ + { + "actor": "tracegraph-import", + "at": 1794698755.65433, + "from_state": null, + "note": "imported review candidate", + "to_state": "review" + } + ], + "dcd8bc21-2b62-4271-9ed5-ee9d34b5f4e9": [ + { + "actor": "human", + "at": 1794698736.2164521, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "bfe2d6e0-6534-49b9-834f-4fa2dab76a48", + "at": 1794698736.8496, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "none", + "at": 1794698737.354914, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "f305a5e1-4109-48ed-b7dd-45776391f3de": [ + { + "actor": "human", + "at": 1794698752.109395, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698752.705991, + "from_state": "planned", + "note": "annotated", + "to_state": "planned" + } + ], + "f4187a31-3f44-420a-99cf-9e76a6889012": [ + { + "actor": "human", + "at": 1794698734.4337862, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "3388503a-0ad2-4440-aded-469f06ee4c07", + "at": 1794698735.063678, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + }, + { + "actor": "codex", + "at": 1794698735.610032, + "from_state": "running", + "note": "run failed", + "to_state": "blocked" + } + ], + "fb625361-3bb5-41f1-a3a2-35776a5d5ad2": [ + { + "actor": "human", + "at": 1794698749.121001, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "human", + "at": 1794698749.7176309, + "from_state": "planned", + "note": "waiting on ops", + "to_state": "blocked" + } + ] + } + } + }, + "running": { + "decisions": {}, + "files": [ + "board.db", + "board.db-shm", + "board.db-wal" + ], + "frozen_at": 1794698760.70875, + "items": { + "killed": "812d1dc4-9188-4fc5-bd8e-b938a1b6cdc0", + "waiting": "83927daf-eec8-4b31-a557-92d4756ead71" + }, + "release_read": { + "active_decisions": { + "*": [], + "backend": [] + }, + "aggregates": { + "transition_counters": [], + "transition_rollups": [] + }, + "decision_rows": [], + "decisions_mapped": [], + "items": { + "812d1dc4-9188-4fc5-bd8e-b938a1b6cdc0": { + "blocked_reason": "", + "claimed_at": 1794698760.70875, + "created_at": 1794698760.043403, + "depends_on": [], + "evidence": [], + "goal": "backend", + "handoff": "", + "human_required": false, + "id": "812d1dc4-9188-4fc5-bd8e-b938a1b6cdc0", + "inputs": [], + "lease_run_id": "16b27654-3d6c-44f7-974d-7943173efa02", + "outputs": [], + "owner_agent": null, + "state": "running", + "task": "killed mid-run", + "updated_at": 1794698760.70875 + }, + "83927daf-eec8-4b31-a557-92d4756ead71": { + "blocked_reason": "", + "claimed_at": null, + "created_at": 1794698759.424586, + "depends_on": [], + "evidence": [], + "goal": "", + "handoff": "", + "human_required": false, + "id": "83927daf-eec8-4b31-a557-92d4756ead71", + "inputs": [], + "lease_run_id": null, + "outputs": [], + "owner_agent": null, + "state": "planned", + "task": "still planned", + "updated_at": 1794698759.424586 + } + }, + "order": [ + "83927daf-eec8-4b31-a557-92d4756ead71", + "812d1dc4-9188-4fc5-bd8e-b938a1b6cdc0" + ], + "stats": { + "aged": { + "blocked_aged": [], + "by_state": { + "planned": 1, + "running": 1 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + }, + "fresh": { + "blocked_aged": [], + "by_state": { + "planned": 1, + "running": 1 + }, + "dropped_handoffs": [], + "false_done": [], + "human_required_aged": [], + "reclaimed_stale": 0, + "redispatched": [], + "stall_seconds": 3600, + "total": 2 + } + }, + "transitions": { + "812d1dc4-9188-4fc5-bd8e-b938a1b6cdc0": [ + { + "actor": "human", + "at": 1794698760.043403, + "from_state": null, + "note": "created", + "to_state": "planned" + }, + { + "actor": "16b27654-3d6c-44f7-974d-7943173efa02", + "at": 1794698760.70875, + "from_state": "planned", + "note": "claimed", + "to_state": "running" + } + ], + "83927daf-eec8-4b31-a557-92d4756ead71": [ + { + "actor": "human", + "at": 1794698759.424586, + "from_state": null, + "note": "created", + "to_state": "planned" + } + ] + } + } + } + }, + "stall_seconds": 3600, + "tracegraph_report": "tests/fixtures/tracegraph/v1.json" +} diff --git a/tests/fixtures/persisted/board/v0.3.0/compacted/board.db b/tests/fixtures/persisted/board/v0.3.0/compacted/board.db new file mode 100644 index 0000000000000000000000000000000000000000..34f5f3a17ccf55d11edcde6c7cd2f67554d82478 GIT binary patch literal 102400 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 LAOHaf975nf68e-X literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.3.0/lifecycle/board.db b/tests/fixtures/persisted/board/v0.3.0/lifecycle/board.db new file mode 100644 index 0000000000000000000000000000000000000000..a0bd73ab5efdf0818a6fb6f7397c9cca8783cfbe GIT binary patch literal 110592 zcmeI53wT>so!}))vMgEBjgvTzYuem6Z5=nc&V4^pN}GnP8`7q)7#f`5ocprX*pe&B zN!=uElt4cq%WQ{f>6D=l*g|($9#cB7JW9VE=q$@JGtBVXw%;|66aqzF2cuw_KS)HCBo(i*1MvR}(QnAz6# zy{?oOaAI zs@M~ixza=l%{bLrWI5G#=T>aJW!sir+t^)OuDyO6+fIUApJm~NlPcQy2wuCk-L{Lp z>6Yy`Y`JAOyJOpKcI$Q9w(elp2STrZ13NS{ywQsXEoLT)=*8Q4<1TjR*!9=@-&@nD zIOEt8(4trtbh(~w{eE_?G8umDeeXxBI8708wCqOKMa5}P6tbMHRoU%3cWoQpcFRV# z5$U)`7Plcae4EgrC11(mABTCrT3u*!3#np3H^Ikmb4R~vzV7KXkU zldt*#G(G2p%0;DR-?;7HZ5g|M7t3ddx2^8%+bzXo#ggsZS-oQ#7*3$MTG!+C)%~-3BN71`>Ho6_x7D{+;$s#js(1RedEry zy=8sWUN^Fh7CJn-qO)&YIa4v)X*40UJG*kS2YUIMcs(7J)OM_56`E~z0$H`<0VfJC zUsR^(t3Z^6LPY1*SLbG-(L;QD!ki!8yR5TMS`$CmCZDQRo^52)bCzs8Np?XtIQDS; zu0pzR&6@b}tzO%Vw1^IvmX;Wu4jW)N615$U{3cj~UhjR~kZB!S0__5sma!@7jYC60 zd#*UB)-n!7J=Yg#q2~>di_QllPj*;fI{UV*Ia6zh$~qxLhs(zEoqfW(_#IJoG&(#~ ze61-|SX3WPU*gdZD!u8KI|n;@z&SM6V)1U zgdw?HgGSKZo$lKL8DD*djO`*^xoXx_QyRH*u+L z(^eNO)TBlCS+&5z3o(be+?46;+prSh4zQ~FqjQ8@vqGbzFdzl zF&ja2_?Xa@?pwDm{`TPo!+g{DUd^dt^ z7v$re^X~JC_V8rN&nXo(;YP|6<%1=s(g=5+EhkTQK~CPe2{h@HYQt|!!o^{2)5W2Y z?!;snO*ew6vt@%ty{kh*emy=nye|P=acz9QT{*k~q!A%`whTPk1?BM04Zq`XJl(f; zZTy6P{b{7vIO+&e_Pbx>{Nf%Hw&$ihV!s#o1q|BiIT~vXRriOIZM&3Tm{8;lU1W9| zl}e61-mrKsj zaBx50)C?e5tVJ*!lxFAPo;!G*LA&w2!R53(S8EbKmozA1K8JA0})WQTslXE+Rm&~va1sy2(NQ#-Q1Czxi)ShaVmHi z^HpgKFyZ+HHzaej_L=TjvcpnGXW!`BGu?qS+WLghI8LNsG971L##8D6=H=Xt*{@_T z&s>*&x${e%yHmeP^(Q}_yeaW?VnfG!;?G?$^X~JYpmlNi^0EAefmlyZPrfT(=VGyR z8fmhCkScPfteBiES|*2VRpTV&ID)|Q7O(Kgg=sQdJ6LAD3uiE#jPLdS4Vt2?DY77O zt_E+i#H*a?>KbPmGS54L1t-+OjqIQZXJthdI0=#kIaB6LK{q*7S42y3RM&Rp!M$5v zc;?EZ&(6Ou{Hzc3^o-?i43*xCbp|bwDJeE5yMoHes;hFk$-A5;St8<1*OC?4*BO;O zmD$=9+#}d!r;2Y#S?A7TwYH!XeDLD%CkLAIoQ~gcFnk5tJ<@x-ryYFO3(G(|rA0eY zF-_UD3{F)rQBCAI!?6@jRwU6B6jfD0eUB(&10_5q7bvs@TnE2d^Av*5dJh8%UD=|L z3N@_Cj>#Fa0Y%enozo@P;tWkSU0JpOm>5*?l*1lyDn+*lgCwr&1v(K`wO@s|JoSg3 zPVi|JK&7bJ_23$GC0;>_BXF|78=R~=HfL%!RH&k9s$>YR1Q!Aa&rw-`1k=@WsZ|v} zlXPsCmkBrW3o{Ry4EyEIIb0*dAX3(lZ7gkA~Zh4Rvg!<;A>oSaSjdchdZFb&FmmtrRLBy z?kymQPfXQnv(?R;HaT}9s0?SMSb}AxqP=OlJh@53ayk|Dx3=De36z7h@|fxhdN>i#W%=Y4+u$@;!-Ab45Wa{OvCRZ)>}mo-gj zz=A7qNJ1hf;c7yPtsq-Gh>CDO02jaVY&E!U1|x%?!{{@Iyc}jue{?bnIe7T+_~YfE z@Q&izhRc~EZkwuVKv!0H7=w^)yC!6#s-<$!C@qB7?bvx|LFe@{y8GA9{2XV5KaZ&y zTv5G!J?oD5g<0vU06kJsIE{A@C!4ay>4NTZ&;@i$fpH3kr>OCp^H5pdT?4)=vdXYP z2c;Uc(6lu&J3qL0yisS9aQSVjF=3OyT2qd-zsd%6bFNyF)e(&s4MQ@bTJka+JhG8( zWaBB*luxxdS>oXS=bVi|)STP>`h$&ZrB62Jp`xO znxGqoz!?&PI?@Fg&^vW^h}#zY5Ic5fR1^sZppl$QJdct=ri>b0S=( z@G>_mi#Ws!GCNt>Gsp9;RXR6Jc|?a%RBlvNE6gL$T=pgpruvqT)yLBSQ|pITSl=DO zR3+Kc6ib9=hhR|R4Vgo{3`9-Mh4yY4hHSgVJ6UM{YznZ=U;d$R`BqfKl790snm+G{MLcKo}ObUpQ(@gLz*n;8j@g0gMJSx z@(3EU<$|6tqN%!W@PZifH<3L(&lXGg`cRy8ri&#f&@`-uvy21$!g1iruqf>8d~FKG zG0tN54B`b877r_Iab~t$so{#hlEs6%f4m-sZfTgk>MB;*GuYBRT{K-?G~!Fjhzhq? zQe(gmYw!-ZuoP?aEFP{RO^B3SijISRJskRzFAw2*IP_xn+4}8C=mtYULpj##RfC}z zhM}7}-2F*#)2JCDXCOo3kY(wzrJJ%PJ1y0)v?lWE7Ix_5yS&2Ajn5uimRLSEAVHts zR^PoNxX5XetSSavJVm(rbFzaJ4hfFKsRG=2=>WhrR1?8;ykwtz&l9KK@y=5Zzny*Q zsmD%z?gJ-JJiegg<5jWhCVcxaGGpTg@rqoNByoi2bzTw{jRY@!>gefvAKT2H{LInQ zfBe~#AAXuW{m=ua9{%j<2OeWz`qXj1{_lG7_Aw7h?D+lly&Zr=z}J+;VLt3eLHVv)vjdm!t`iSkTi+Rn_C4SY^W)(#uk$Lj zVMFH(7vI;IiVl+^-sUvfl;8%}5>=>tf0$oTzpqGjiu#D8@VcQa9vA!q%|G?%zd(Ut zmV43iEWEGC{W6xnqtKhbt}t2nVgCKhy@k&)&lT=t_U2FJ*D#;V{gUaaBZ#WMo z#PPy&Y4=_iVI~a%A&D_9jVHD<<%nzBTK#aa90ZM=p zpaduZN`Mle1SkPYfD)htD1q~wKsM1I_aEP{=uQm8gFT(gn~r;$j+ZqZGfl^ZrsI6m zaSk5``(C=6&S$$4y>Yw;A`>2TH55rVMe1xiPBk4T8{&yDiH=O7KjW9hpa1_sjQI`o zJ>~`G+sxlGUt|6o^B2t1%zt4%#eAIkPt1R09$_A0e#ZO*^9Sd771QET0+awHKnYL+ zlmI0_2~Yx*03|>PPy(+CfyP{YMKY0(FUM~^_-z?}WAIx6zvb~;4!?Edw=90k;I}UP zmd04kg@GY6Sp!ES&b z!HU2a;o1M6!s@_RUKI#56H0&*paduZN`Mle1SkPYfD)htC;>{~d?Aob#Nsf;kKrkP z3{UZ6c#02}`0yJ{@nd+3AH!4p7@p$C;@M21FYehT$V5k7(NP*d*~b=DI-^sm@KiE7 zm57cyx)OaEFExMu{~`SR|5waE!+ih8FysGw=6U8@%-7);0e{K-SLO@MXP76Mk1PPy&5tr@a%tSO9eOv>;{P8-2gGX8z6>v z1H|xdfLJ_<-xBx@p8v;!=l|Il^K<4!c*6hJFyDWQ`3UUy|M$#2Oa&|e+{Wx+-oOaV zrA!}#7Ypc%5}*Vq0ZM=ppaduZN`Mle1SkPYfD(936UZgfact)Q=uf_XVnq}H?_|rP z05}2bi2~q&YgrTk&sR(o08dqgFo0c2<)Z+2V9G@SaF)~^2CyTeY!m<|J()0ooy>HF z0qm0{9RCg0Gw1L!vJ>Akca}{%b=q>kElS8*nZIeFH>3_5#}xo;RVu=cAVp zG`7(z!h}eyiJmDTXsDyZVL~LVBi@W^i>;9y95?n1JweHBwl*h`5X4)(c^h3D>bHbs z7wHFM;V2s>L}DoR40V9V(XDGBq5j^!e450Ntly)tg%wXJT&%mnIhuP3rq$nf16d-z zt6e`WZ(o(?>I%G9VMl(@V!_K(h|d@D^7+_rUzoWV=QA)iK$K5V>cF$FVepP@3j#Rf z6tQ0=uwaZ7uwX0-COF)*ZAsIez}2jm-Mz;j9(`R1nS{-mAj9=(>p%#Z#0YOY$lx^1 zy(olCl*sP}x$qZ*GyNfCl6+brJE9~RrVD%p!vY^}0{C##WQ&s=(UcrX(|FTpf_&sf zqi1w=2zd$FE$kBby6^Udd`Ju!2d!d>jS#zcn^_g|A<3tek84PxCg}(qvf3JU7zjSr z98Cu|a1J=+bOjTfv^MjZeQ4*NUN5_TB~6lDP^=)=>Uwp5DD{(J5{?PVr`XLJ}k?wpOd@I-;#Q zJUF(Mz;zx_06(&_3to7UXe02fiojNS6A5+V`O#$|i6vyWu-Rj$em66o-hFG+Bv!Ut zNqB>AD+=tFZl(~TAW5e=-CxF zjOIfWOUP~^3Vcg{Q_j;H8U=|R@m3UgKkxz);IwY0J0wApVk-&9b!8r0S8|$TgQGLv z0AI|80Pdt!9o#Uh2sujg1?SMsYrj334M{8^yG0~mKI3Mv-uQw{VkkWzvBa_P5O}bg z=?eLf1`z48H$N-r;mvbvWAukC?m!&TpM&K6kzFzITtNLq1E$ZXq8$ z#oOD7_3rJvI!$69KHw8M*IRVE68d<>V+nSAHhjo=EV%qN zEl1*PSG2J=aqvNknmW*3&QsTpCPOSs$Zio9nC!X6W^)g~`Gj3ccBtnM;_xjLdX*{UU!y{<{2{%*o7`@~84&&c8qV+3bHfKd{kKPy&NGo;FA-xE2eNY$#)~AjzhvHKc-4qNV2DBfK>1z zQo(*w!PQuhWGhS`so*M7!Cq3qm860zupr59mgS^^J*0xmupr6q5r$N-Kq{EWf+X8D za-@RYq=H#2NU{?mLn_!sDwxKCB)bhdNd;4+f=Mh$@*qD!D%dfU7|W2P=*|B-zZOgH z>w15BB%^izCjH*RiR_Ea*RxFi$6cE`f5U9dJ(m7${*9Sb=hwRastcu`?f!E2&4pXC zpJ3jX`A+_mh5wVA%y(zEWQzF%xslvA3SaDgcXxl`qU-_YZJ9@2^Y;q00F(eFKnYL+ zzwZS2RIGn2aM4RNyAx8efw9n$FVQrwB?i%auO$Z2#IGd=(F{;e!4F8nas*ooiDrZ? zS&_uJyd?(F9I>5pM03WLtVm+4Yso6u8Bg+~q`{V~NMfvQi9s~IlvDk^QR{@A*+f%K zEj56fbn_2iNa9`6LL!Jx67k}ea*@P%-NJGaO;6jDizMDf?aDj|LNyM%e6-i>GmDB(pQ~lu)|CWJh z`rb}Kl8C7m1xaEg+b|@VlqcG$ND{FF?tuozGQsFU62qJScb|$CzFxSmaC7df`P=h3 z#>_pML*NVGA!cXc*M%<>4i~P<|9Sq+x&NE{huo)gCvpdKH{^`mWx1Y07xQtZkpJ)b zT7FgcDexNb4rX)Vp9)VDrV7LPpXVRTU;F!h(@6EB1SkPYfD)htC;>`<5}*XmR|1zN z`>zhxN6%=`YU7IJz(BZ`7+6W#(B|9~ZO#q1Ik&zyIj|;7FEZdX)JF31Hs>yD8~f5W zlIt!?4h+YGC5h0~j&G@Gu#NcIHs{z(vNs>c)5tX&lKnRXq!#@$et{vMOT3hVIcV@J z_KVx3{<{t$cJ6s$H`nEU!&;KQ%{r|#m3qLFTsPLV_R|`)UK3Vus;eoPQRvM7KllZ}_wwI>gz1YCpaduZN`Mle1SkPYfD)htC;>{~ zUynd&-5r~*-xvkJn)rq&02aZohyq~MdpHV!W$yJ+0E}u6MFB93eR&wb#;q@l0$`W= z(kKA7rPoCPun0XE1;DEF+Ax4EGqX_uEG(~y0$>LDk|+R1iZ6}=U}*StQ2-1E4@3d5 z>U&Wbz&3aLqX5{=T^$9$xNTn)0MoOp8iDtIyEhDAJFY9E0N7%U?Ehmks*(Nw!(ikz zvj2|_l}7gev5C>h{y#PV8rlEHMm!_?|A)Z-W@P^#TgQy-{~rPimy!K{Y=$zj|BsDC zM)v=)p~uMnKQ_x4+5g8z6C?ZocY)!6(+5b-!-VkH{Gqa=ceBqDa zkiIAZN`Mle1SkPYfD)htC;>`<5}*VqfdvF^O{K@S^`>JnL$q{WvLwzlZG)2~+2#z< zRls|SU>KrlJAz@}I#rxyYf}zum#r#$uvnY&LfB)+2tI{f4b-2Qy!nmE^w_36B&zVb zqw`4POhXYkS&?i`*99ID1?M}wXh{Yy-Z~4e+Nv8_@C?S*kXaq^QmJ3`)7gZV%2-+! z1VwTcl`}LA+;<>D=a8#AoWpCf46bTKSu}P*Oh1jPm!6->xb|@p6~Y|f){!0qKTfe2 zI0bQ4aJ|IY68M6UMaSR}4_HiD;7wC@MPA@f{@IhK9=!kLAAR8DyYFXjz4`iL%{lqu zr`b~e(fwkm?|ro)-wa0A?s@Zf<% zQC-e8C7V}}r0}*rR(0691FT!FunzW)!`?Jsn}Yo?;E`$uoY(mUWU9B}=l>~2j$zAw zo*lpE7F00}QUa6!B|r&K0+awHKnYL+lmI0_2~YwTC;@DQk7U8av;Rl3g5cTzBUz{L z?EjH0FL?IJ%s(+dW4?QVRw^wvB|r&K0+awHKnYL+lmI0_2~Yx* z044BRCD4`V1SgJQA zKnYL+lmI0_2~Yx*03|>PPy&TZhaOGgP%0+awHKnYL+lmI0_37k&^_GP-p#?tU} z;g};zl3}_MCkuwf$-E$Q;O*4n;8)b}OKM5ec+(*9iHLvbjBTyq&$~Z<+jsVLg*mu} zBx;h5I8CxOPSyp)!7rqRTSRA=|Ox7u<#mo4Os@ z;x!WYfjDJsWX>zgTi$c=zGRq#ITB~PqOB>ipg>)aIN$Sf0IPUj4zV9yu`eFxz{|WX z8j8(Xx(O}FbPBKLOLsxq%w53;|$K962y5p1$ zgLh@9o_=SN?Z03|>PPy&coO1YdPNU|4Ei)yyx~L zD=Xgb|49}|yx;$mtaD_UKaXXZ!5H%;#%BJOd5L+1c_&k0b}~Agq%TT<5}*Vq0ZM=p zpaduZN`Mle1SkPY;DRC0n@p$U-s5uE@`69{7MM)qENoNp&ce2puITI$*jj?m;;kl~ z`D83e0Y7k$WDdjD4J?DVa-^cOhhV#fcNVr^BpYX8iv&K4w@f6Me~cA8jXX`F)bXa1 z^h(e+<4MAX1pJ9NC_r7M;*GRmGlVArnP zPy&(raAgi7hni8M{C;>`<5}*Vq0ZM=ppaduZO5g$_K%f6#K$T64 zN(oQ`lmI0_2~Yx*03|>PPy&`< z61ac};OGC#{Yv)o%ysFPJHOPqJN2tnfAZ7Gn-WhaHgvoPgy`!v zL!d4$Up|)KFc9nM>B)EH>s&0BPJ`DM0U;IqfyfHDI1w!q9FV9QCn50DBJjM$D?D;* zPKB)e{Y6xEEWYIQs1T`@+xqKu^zD{>D)0y;x_^5}6V>>yTYR1y?C9xHK_&@NgnoB6yW? z!LNzz>x@dC%4}^4)mXdiRM}Fw#yWQvtF;BC;DZ;3Kfz53yy^H22g6sO-6OrXd)mQg zy|4_lQ(CkW71NYW%K*1Dn5ZW5;P}Q;I9ZWIQ&3b@1@%3mhz*qRlw6?D5^x>-X3bLw zKI=UUD0F3uLMqg-Dmx};fEyc7$kxG6j%#s-rkddY!vbJpP{mUYd%&p_-J)Z+(}}36 z{VKfWsXz2|f={aeDn-q%2iKr0@d{EL0o)Jq1~>--k2j`fLxn1urb>q3O14vS9Pot0 z0wkwWEtgvH_?e_*ySz-ekzbg3$Yj_rcP8&;V(2<}8WO>$3o?VIZGu-IPDVQKn&7}k zab28A^=x_E^Mjsia31)xKAwXPB;icz2cZXfxscS8g({UIG(N;u9M`EhCCh0p&Y{8m z#gaX^nH`)#r8zW>dkYBS6H~R?Y<2UdP0pQYW_H>cDV7eP>7u=9x;(i_!*a8zT6J*T zT4m0GFsi|^pc&vmNY@m8#1J%IGDP^soc9u(gFFV0K;QLBb^n&X^FBZSWPM*Z5WFmG zIes;ns;Ee~%bF%MV8InQBq5QLa5W*tR={b|K~$_&*>Z_3&sNRpvb8@N8T=eZpE=~^ zFmw8&lUc~Y!-vNoF9(Hpz(0`Ta;AvermBJuC+yw_*~qqC6S7g&QaNap7OE8?qj_gR z=k+qW``6F>9A|_-kEt14QN4XV>yGz@S&_KFi5kB-50y2AS=r^1W0h^^P8jV5Ei`S7 z%+3$)9dFdxB&s=0H70BlSZm6$_E*`UZq8LpvO1#iqG3ozR7+llgGV;9jchz+n)0a@ zCrez}b2xe_ajI0UZG*vZPCIi7c|(z#*EBRY(ta-*tR zVIFzrvNw4!)wg`CKAr}cT0gYH`tA@WiMuejcqa?ZpAD}PRs~h3D$aqTbMO^ziQ)+K zcJQVZHI;yBFkBoya@~({>5e?OZgu^VPUy|bKrgU%CTOr8c00OwN%5>n#ikL*rAi} z@(MdQK6`9gV)@vB1bu#6efN&wB1hu<&O~tKEZHaD^Terlyz|takOw`@qQ) zk1y!>a0Ba9H{sidkr^8|h*#vAB#9$Duk(_yXe4;)Q%6tV``Bjo4zRT_3&p;Kkyj)(x;C5^?%osw~u*9V#n{V@9h920=}j+hCz}$$pA^%4B%4Cy2Vnl zI`zt5UL<}*&;?O!4D(?(3d(oYnjN@&cb$0X+WO8owC@3Lm>&;^c@kfNLBST(?<-QB zqCO%iybfL~7uBa`<5}*Vq0ZM=ppaduZ zO5pdFz}v50v2v`xzNSBR{7}!a@qF+w#5Q?kYnsSuNZ>gI*1+J2A2^9ubivU?)zM7e z@Mog8cngi}t_rf8$qJgCVr%8{G*@wIm3a=Y#?4inYYvEbE^gx$Jhxn7tMesmrZ_#l zd9ztY6?>vuL$#`(-1uO%JXf)t&9x}O5&s)_E(0mpupU*t=74~gGGJA9qG)e+Tw73G zOW-s`ci`!eYja3b70xszN7QsdfqAUI6jp-=lcmjV^}_=Ai;4Zt{N}d$VF^^J6|^TP9afIH;eH2MB+8ql}*jGRME9zEd&X=E{gDIN>nX)hzAcE5#m(`R@*ci z9+dF9=&F`sDWYz|1A^wI!A8-&Qu>c}{a OM}PAD6L|iQKmR|+NcIf? literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.3.0/lifecycle/board.db.gc-lock b/tests/fixtures/persisted/board/v0.3.0/lifecycle/board.db.gc-lock new file mode 100644 index 0000000..e69de29 diff --git a/tests/fixtures/persisted/board/v0.3.0/running/board.db b/tests/fixtures/persisted/board/v0.3.0/running/board.db new file mode 100644 index 0000000000000000000000000000000000000000..c5a23d9cdbb93df99fe210c983642e7a2b0e1acd GIT binary patch literal 102400 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 HUj)7Y0S+iX literal 0 HcmV?d00001 diff --git a/tests/fixtures/persisted/board/v0.3.0/running/board.db-wal b/tests/fixtures/persisted/board/v0.3.0/running/board.db-wal new file mode 100644 index 0000000000000000000000000000000000000000..6c988d7f3241d328d4ddc8ae7165662b7a383f0b GIT binary patch literal 49472 zcmeI*Ply{;9Ki86GrP@hchlFnF6xedT0FEX9o)&kNe~fFJ$UdS0mUj#W+pZ6?kM}` zB1q{XiwK@PDX0~sh*;}Idh0z$Y1^b@u~UrxnkixwafhL{x4{)3U^%lv99f7swx{ya?tTqe;5I_I{1Q0*~ z0R#|0009IxqQJa0A{w^curt*SB;TDTu^*!TU1=XJ8c zlB+@}zfqk(l}Uy_SRniH6}sN>S4L9$OpyhTTyUN11Y zeS7}$(bo=i^8y_qFUy}~r%zp2HUbDBfB*srAbo_dC+Oz`0XXug`uq^>sHda7oBZ{S`N>MF0T=5I_I{ a1Q0*~0R#|00D*rM7#|YdI)W8v&-5QBoXx8M literal 0 HcmV?d00001 diff --git a/tests/test_frozen_board.py b/tests/test_frozen_board.py new file mode 100644 index 0000000..c460376 --- /dev/null +++ b/tests/test_frozen_board.py @@ -0,0 +1,786 @@ +"""Released work-boards, read by the current readers (#271, persisted contracts D). + +The databases under ``fixtures/persisted/board///`` were +written by that release's own ``syncmill board`` commands (see ``freeze.py`` +there) and are never regenerated by the current writer. ``bindings.json`` holds, +per scenario, what the RELEASE's own interpreter read from a scratch copy of +each database: every item through ``Board.get``, its transitions, the active +decisions, every decision row through ``_row_to_decision``, and ``stats`` at +fixed clocks. Those reads are the interpretation HEAD must keep; the raw cells +are checked beside them, so a reader and a writer drifting together still fail. + +The board stores nothing bound to the generating machine (freeze.py refuses a +cell holding its paths or hostname), so nothing is rebound. Every test works on +a copy; HEAD opening a released database adds columns and tables to it. +""" + +from __future__ import annotations + +import dataclasses +import enum +import json +import os +import shutil +import sqlite3 +import stat +from pathlib import Path + +import pytest +from click.testing import CliRunner + +from syncmill import cli as cli_module +from syncmill.board import ( + Board, + BoardStats, + Decision, + Evidence, + WorkItem, + WorkState, + _row_to_decision, + lesson_source, + render_board, + render_board_stats, + render_decisions, + render_item, +) +from syncmill.cli import cli + +FROZEN = Path(__file__).parent / "fixtures" / "persisted" / "board" +RELEASES = sorted(p.parent.name for p in FROZEN.glob("v*/bindings.json")) +REPORT = Path(__file__).parent / "fixtures" / "tracegraph" / "v1.json" + +#: scenario per release; v0.1.2 has no `board compact`. +SCENARIOS = { + "v0.1.2": ["crash-blocked", "lifecycle", "running"], + "v0.2.0": ["compacted", "crash-blocked", "lifecycle", "running"], + "v0.3.0": ["compacted", "crash-blocked", "lifecycle", "running"], +} +CASES = [(r, s) for r in RELEASES for s in SCENARIOS.get(r, [])] + +_WORK_ITEMS = [ + "id", "goal", "task", "state", "owner_agent", "inputs", "outputs", "evidence", + "handoff", "human_required", "blocked_reason", "depends_on", "lease_run_id", + "claimed_at", "created_at", "updated_at", +] +_TRANSITIONS = ["id", "item_id", "from_state", "to_state", "actor", "note", "at"] +_DECISIONS = ["id", "text", "scope", "created_at", "superseded_by", "superseded_at"] +_LEDGER_V1 = ["run_id", "item_id", "claimed_at", "purged_at"] +_LEDGER_V2 = [*_LEDGER_V1, "reclaimed_at", "failed_attempts", "next_attempt_at"] +_ROLLUPS = {"transition_rollups": ["item_id", "claim_count"], + "transition_counters": ["name", "value"]} +#: The schema each release wrote, read from its database. +TABLES = { + "v0.1.2": {"work_items": _WORK_ITEMS, "transitions": _TRANSITIONS, + "decisions": _DECISIONS, "board_run_namespaces": _LEDGER_V1}, + "v0.2.0": {"work_items": _WORK_ITEMS, "transitions": _TRANSITIONS, + "decisions": _DECISIONS, "board_run_namespaces": _LEDGER_V2, **_ROLLUPS}, +} +TABLES["v0.3.0"] = TABLES["v0.2.0"] +_INDEXES_V1 = [ + "idx_board_run_namespaces_purged", "idx_decisions_active", "idx_decisions_scope", + "idx_transitions_item", "idx_work_items_goal", "idx_work_items_lease", + "idx_work_items_owner", "idx_work_items_state", +] +_INDEXES_V2 = sorted([*_INDEXES_V1, "idx_transitions_reclaim", "idx_transitions_redispatch", + "idx_work_items_created"]) +INDEXES = {"v0.1.2": _INDEXES_V1, "v0.2.0": _INDEXES_V2, + "v0.3.0": sorted([*_INDEXES_V2, "idx_transitions_at"])} +#: What HEAD's first open adds to each release's schema (all nullable or new). +ADDED_COLUMNS = { + "v0.1.2": {("board_run_namespaces", c) for c in _LEDGER_V2[4:]} + | {("decisions", c) for c in ("project_id", "provenance_json", "source_key")}, + "v0.2.0": {("decisions", c) for c in ("project_id", "provenance_json", "source_key")}, +} +ADDED_COLUMNS["v0.3.0"] = ADDED_COLUMNS["v0.2.0"] +ADDED_TABLES = {"v0.1.2": set(_ROLLUPS), "v0.2.0": set(), "v0.3.0": set()} + + +def _bindings(release: str) -> dict: + return json.loads((FROZEN / release / "bindings.json").read_text(encoding="utf-8")) + + +def _cells(db: Path) -> dict[tuple[str, str], list]: + conn = sqlite3.connect(db) + try: + tables = [r[0] for r in conn.execute( + "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'" + )] + cells: dict[tuple[str, str], list] = {} + for table in tables: + columns = [r[1] for r in conn.execute(f"PRAGMA table_info({table})")] + rows = conn.execute(f"SELECT * FROM {table} ORDER BY rowid").fetchall() + for index, column in enumerate(columns): + cells[(table, column)] = [row[index] for row in rows] + return cells + finally: + conn.close() + + +def _schema(db: Path) -> tuple[dict[str, list[str]], list[str]]: + conn = sqlite3.connect(db) + try: + tables = { + name: [r[1] for r in conn.execute(f"PRAGMA table_info({name})")] + for (name,) in conn.execute( + "SELECT name FROM sqlite_master WHERE type = 'table' " + "AND name NOT LIKE 'sqlite_%' ORDER BY name" + ).fetchall() + } + indexes = sorted(n for (n,) in conn.execute( + "SELECT name FROM sqlite_master WHERE type = 'index' AND name NOT LIKE 'sqlite_%'" + )) + return tables, indexes + finally: + conn.close() + + +def plain(value): + """A dataclass as the JSON freeze.py stored the release's reads in.""" + if isinstance(value, enum.Enum): + return value.value + if dataclasses.is_dataclass(value): + return {f.name: plain(getattr(value, f.name)) for f in dataclasses.fields(value)} + if isinstance(value, (list, tuple)): + return [plain(v) for v in value] + if isinstance(value, dict): + return {k: plain(v) for k, v in value.items()} + return value + + +def _item(read: dict) -> WorkItem: + return WorkItem(**{ + **read, + "state": WorkState(read["state"]), + "evidence": [Evidence(**e) for e in read["evidence"]], + }) + + +#: Fields HEAD's Decision has and no release stored: a released decision is +#: unbound and was never promoted. +_UNBOUND = {"project_id": None, "provenance": None} + + +def _decision(read: dict) -> dict: + return {**read, **_UNBOUND} + + +class Frozen: + """One release scenario copied into ``tmp_path`` with the board enabled on it.""" + + def __init__(self, release: str, scenario: str, tmp_path: Path, monkeypatch): + self.release = release + self.scenario = scenario + self.bindings = _bindings(release) + self.facts = self.bindings["scenarios"][scenario] + self.read = self.facts["release_read"] + self.items = self.facts["items"] + self.decisions = self.facts["decisions"] + self.frozen_at = self.facts["frozen_at"] + self.stall = self.bindings["stall_seconds"] + self.source = FROZEN / release / scenario + self.dir = tmp_path / "board" / scenario + shutil.copytree(self.source, self.dir) + self.db = self.dir / "board.db" + self._monkeypatch = monkeypatch + monkeypatch.setenv("SYNCMILL_BOARD__ENABLED", "true") + monkeypatch.setenv("SYNCMILL_BOARD__DB_PATH", str(self.db)) + monkeypatch.setenv("SYNCMILL_BOARD__STALL_SECONDS", str(self.stall)) + self.clock(self.frozen_at) + + def clock(self, now: float) -> None: + """Fix the clock of every board the CLI opens, and of the evidence it stamps.""" + def build_board(config): + return Board(config.db_path, now=lambda: now, + lease_timeout_seconds=config.lease_timeout_seconds, + stall_seconds=config.stall_seconds) + self._monkeypatch.setattr(cli_module, "build_board", build_board) + self._monkeypatch.setattr(cli_module.time, "time", lambda: now) + + def board(self) -> Board: + return Board(str(self.db), now=lambda: self.frozen_at, stall_seconds=self.stall) + + def cli(self, *argv: str): + return CliRunner().invoke(cli, list(argv)) + + def rows(self, sql: str, *params) -> list[sqlite3.Row]: + conn = sqlite3.connect(self.db) + conn.row_factory = sqlite3.Row + try: + return conn.execute(sql, params).fetchall() + finally: + conn.close() + + def expected_items(self) -> list[WorkItem]: + return [_item(self.read["items"][i]) for i in self.read["order"]] + + +@pytest.fixture +def frozen(request, tmp_path, monkeypatch): + def install(release: str, scenario: str) -> Frozen: + return Frozen(release, scenario, tmp_path, monkeypatch) + return install + + +def _last_line(result) -> str: + return result.output.rstrip("\n").splitlines()[-1] + + +# ── inventory ───────────────────────────────────────────────────────────── + + +def test_every_release_freezes_every_scenario(tmp_path): + # A release directory that lost a scenario, or a scenario that lost the + # shape it was frozen for, would silently shrink coverage. + assert RELEASES == ["v0.1.2", "v0.2.0", "v0.3.0"] + for release in RELEASES: + bindings = _bindings(release) + assert bindings["release"] == release[1:] + assert sorted(bindings["scenarios"]) == SCENARIOS[release] + for scenario, facts in bindings["scenarios"].items(): + source = FROZEN / release / scenario + assert sorted(p.name for p in source.iterdir()) == facts["files"] + assert ("board.db-wal" in facts["files"]) == (scenario == "running"), scenario + # A normal connection on a copy WITH the sidecars: an immutable + # read of the original would not see rows still in the WAL. + scratch = tmp_path / release / scenario + shutil.copytree(source, scratch) + tables, indexes = _schema(scratch / "board.db") + assert tables == TABLES[release], (release, scenario) + assert indexes == INDEXES[release], (release, scenario) + conn = sqlite3.connect(scratch / "board.db") + conn.row_factory = sqlite3.Row + ids = {r["id"] for r in conn.execute("SELECT id FROM work_items")} + assert ids == set(facts["release_read"]["items"]) == set(facts["items"].values()) + if scenario == "running": + # The killed claim's lease and its ledger row, written in one + # transaction and never purged (the run never finished). + item = conn.execute("SELECT * FROM work_items WHERE id = ?", + (facts["items"]["killed"],)).fetchone() + ledger = conn.execute("SELECT * FROM board_run_namespaces WHERE run_id = ?", + (item["lease_run_id"],)).fetchall() + assert item["state"] == "running" and item["lease_run_id"] + assert [(r["item_id"], r["claimed_at"], r["purged_at"]) for r in ledger] == [ + (item["id"], item["claimed_at"], None)] + conn.close() + + +@pytest.mark.parametrize("release", RELEASES) +def test_released_lifecycle_holds_every_shape_the_tests_read(release): + read = _bindings(release)["scenarios"]["lifecycle"] + items = {role: read["release_read"]["items"][i] for role, i in read["items"].items()} + shapes = {role: (it["state"], [(e["kind"], e["passed"]) for e in it["evidence"]]) + for role, it in items.items()} + assert shapes["passed"] == ("review", [("gate", True)]) + assert shapes["verified"] == ("done", [("gate", True)]) + assert shapes["pipeline-gate-failed"] == ("blocked", [("gate", False)]) + assert shapes["route-gate-failed"] == ("blocked", []) + assert shapes["evidence-done"] == ("done", [("gate", True), ("manual", True)]) + assert shapes["signed-off"] == ("done", [("gate", True), ("human", True)]) + assert shapes["imported-1"] == ("review", [("tracegraph", False)]) + assert items["handed-off"]["handoff"] and items["handed-off"]["outputs"] + assert items["needs-missing"]["depends_on"] == [_bindings(release)["missing_dependency"]] + assert len(items["imported-1"]["inputs"]) == 5 + + +# ── HEAD's first open of a released database ────────────────────────────── + + +@pytest.mark.parametrize(("release", "scenario"), CASES) +def test_head_open_adds_its_schema_without_touching_a_released_cell( + release, scenario, frozen, tmp_path +): + f = frozen(release, scenario) + # The baseline comes from a second copy: reading it replays and + # checkpoints a killed run's WAL, and HEAD must open the original shape. + pristine = tmp_path / "pristine" + shutil.copytree(f.source, pristine) + before = _cells(pristine / "board.db") + + f.board().close() + after = _cells(f.db) + + for key, values in before.items(): + assert after[key] == values, key + added = set(after) - set(before) + tables = {table for table, _ in added} + assert {k for k in added if k[0] not in ADDED_TABLES[release]} == ADDED_COLUMNS[release] + assert tables - {t for t, _ in ADDED_COLUMNS[release]} == ADDED_TABLES[release] + for key in added: + assert all(v is None for v in after[key]), key # nullable columns, empty tables + for name in ("board.db", "board.db-wal", "board.db-shm"): + path = f.dir / name + if path.exists(): + assert stat.S_IMODE(os.stat(path).st_mode) == 0o600, name + + # A second open changes nothing: the migration and the ledger backfill + # leave a migrated release alone (every release claimed and wrote its + # ledger row in one transaction, so there is nothing to backfill). + f.board().close() + assert _cells(f.db) == after + + +# ── the item reader ─────────────────────────────────────────────────────── + + +@pytest.mark.parametrize(("release", "scenario"), CASES) +def test_get_reads_every_released_item_as_the_release_did(release, scenario, frozen): + f = frozen(release, scenario) + board = f.board() + try: + expected = [f.read["items"][i] for i in f.read["order"]] + assert plain(board.list()) == expected + for state in WorkState: + assert plain(board.list(state=state.value)) == \ + [i for i in expected if i["state"] == state.value], state + for goal in sorted({i["goal"] for i in expected}): + assert plain(board.list(goal=goal)) == [i for i in expected if i["goal"] == goal] + for item_id, expected in f.read["items"].items(): + got = board.get(item_id) + assert set(plain(got)) == set(expected), "WorkItem fields changed" + assert plain(got) == expected, item_id + assert board.transitions(item_id) == f.read["transitions"][item_id], item_id + finally: + board.close() + # The raw cells too: the release read them the same way, but a stored + # value has one meaning of its own (a scalar is passed through, a list + # column is JSON, evidence is a JSON list of Evidence fields). + board = f.board() + try: + for row in f.rows("SELECT * FROM work_items"): + got = board.get(row["id"]) + for column in ("goal", "task", "owner_agent", "handoff", "blocked_reason", + "lease_run_id", "claimed_at", "created_at", "updated_at"): + assert getattr(got, column) == row[column], (row["id"], column) + assert got.state.value == row["state"] + assert got.human_required is bool(row["human_required"]) + for column in ("inputs", "outputs", "depends_on"): + assert getattr(got, column) == json.loads(row[column]), (row["id"], column) + assert [dataclasses.asdict(e) for e in got.evidence] == json.loads(row["evidence"]) + finally: + board.close() + + +@pytest.mark.parametrize(("release", "scenario"), CASES) +def test_board_list_and_show_render_the_released_items(release, scenario, frozen): + f = frozen(release, scenario) + items = f.expected_items() + shown = f.cli("board", "list") + assert shown.exit_code == 0, shown.output + assert shown.output == render_board(items) + "\n" + for state in WorkState: + shown = f.cli("board", "list", "--state", state.value) + assert shown.exit_code == 0, shown.output + assert shown.output == render_board([i for i in items if i.state == state]) + "\n" + for goal in sorted({i.goal for i in items}): + shown = f.cli("board", "list", "--goal", goal) + assert shown.output == render_board([i for i in items if i.goal == goal]) + "\n" + for item in items: + shown = f.cli("board", "show", item.id) + assert shown.exit_code == 0, shown.output + assert shown.output == render_item(item, f.read["transitions"][item.id]) + "\n" + + +@pytest.mark.parametrize(("release", "scenario"), CASES) +def test_board_list_prints_one_row_per_released_item(release, scenario, frozen): + # Independent of render_board: one row per item, in the release's order, + # each naming its id, state, goal and flags. + f = frozen(release, scenario) + rows = f.cli("board", "list").output.splitlines() + assert len(rows) == len(f.read["order"]) + for row, item_id in zip(rows, f.read["order"]): + item = f.read["items"][item_id] + assert row.startswith(f" {item_id} {item['state']:<8} "), row + assert (f"[{item['goal']}] " in row) is bool(item["goal"]), row + assert ("human-required" in row) is item["human_required"], row + assert (f"deps={len(item['depends_on'])}" in row) is bool(item["depends_on"]), row + task = item["task"] if len(item["task"]) <= 60 else item["task"][:57] + "..." + assert f"{item['state']:<8} {'[' + item['goal'] + '] ' if item['goal'] else ''}{task}" \ + in row, row + + +def _show_lines(item: dict, transitions: list[dict]) -> list[str]: + """Every line `board show` must print for a released item, written out from + the release's read and the documented field labels, not from render_item.""" + lines = [ + f"id: {item['id']}", + f"state: {item['state']}", + f"goal: {item['goal'] or '-'}", + f"task: {item['task']}", + f"owner: {item['owner_agent'] or '-'}", + ] + for label, key in (("depends: ", "depends_on"), ("inputs: ", "inputs"), + ("outputs: ", "outputs")): + if item[key]: + lines.append(label + ", ".join(item[key])) + if item["handoff"]: + lines.append(f"handoff: {item['handoff']}") + if item["human_required"]: + lines.append("human: REQUIRED") + if item["blocked_reason"]: + lines.append(f"blocked: {item['blocked_reason']}") + if item["evidence"]: + lines.append("evidence:") + for e in item["evidence"]: + by = f" (by {e['by']})" if e["by"] else "" + lines.append(f" - [{e['kind']}/{'pass' if e['passed'] else 'fail'}] {e['ref']}{by}") + if transitions: + lines.append("history:") + for t in transitions: + note = f" — {t['note']}" if t["note"] else "" + lines.append(f" {t['from_state'] or '·'} → {t['to_state']} " + f"[{t['actor'] or '?'}]{note}") + return lines + + +def _printable(text: str) -> str: + # The one escape the released rows need: a multi-line failure reason is one + # display line (printable_name shows LF as the four characters \x0a). + return text.replace("\n", "\\x0a") + + +@pytest.mark.parametrize(("release", "scenario"), CASES) +def test_board_show_prints_every_field_of_every_released_item(release, scenario, frozen): + f = frozen(release, scenario) + for item_id in f.read["order"]: + item = f.read["items"][item_id] + transitions = f.read["transitions"][item_id] + shown = f.cli("board", "show", item_id) + assert shown.exit_code == 0, shown.output + expected = [_printable(line) for line in _show_lines(item, transitions)] + assert shown.output.splitlines() == expected, item_id + + +@pytest.mark.parametrize("release", RELEASES) +def test_board_show_prints_each_released_shape(release, frozen): + # Literal lines, independent of render_item: a reader and a renderer that + # drifted together would still pass the comparison above. + f = frozen(release, "lifecycle") + + def show(role: str) -> list[str]: + shown = f.cli("board", "show", f.items[role]) + assert shown.exit_code == 0, shown.output + return shown.output.splitlines() + + assert " - [gate/pass] 1/1 checks passed (by codex)" in show("passed") + gate = (' - [gate/fail] 0/1 checks passed; failed: ' + 'python -c "from calc import add; assert add(2, 3) == 5" (by codex)') + lines = show("pipeline-gate-failed") + assert gate in lines and "human: REQUIRED" in lines + lines = show("evidence-done") + assert "state: done" in lines + assert " - [manual/pass] CI ✓ run 42 — grün (by human)" in lines + assert " - [human/pass] sign-off (by human)" in show("signed-off") + lines = show("handed-off") + assert "goal: backend" in lines and "task: 덧셈을 고친다" in lines + assert "handoff: 검토: 부호를 확인할 것" in lines + assert "outputs: notes/plan.md, calc.py" in lines # the block's, then the changed files + assert f"depends: {_bindings(release)['missing_dependency']}" in show("needs-missing") + assert (f"depends: {f.items['verified']}, {f.items['annotated']}" + in show("needs-two")) + lines = show("imported-1") + imported = f.read["items"][f.items["imported-1"]] + assert f"inputs: {', '.join(imported['inputs'])}" in lines + assert [i.split(":", 1)[0] for i in imported["inputs"]] == [ + "source", "run_id", "pattern", "tool_key", "artifact_digest"] + assert imported["inputs"][0] == "source:tracegraph.review-candidates@v1" + assert "history:" in lines and " · → planned [human] — created" in show("passed") + assert " running → planned [system] — stale-claim recovery" in show("reclaimed") + + +@pytest.mark.parametrize("release", RELEASES) +def test_board_show_reads_a_released_crash(release, frozen): + f = frozen(release, "crash-blocked") + crashed = "orchestration crashed: RuntimeError: frozen: injected orchestration failure" + cancelled = "orchestration cancelled by operator (SIGINT)" + for role, note in (("crashed", crashed), ("interrupted", cancelled)): + lines = f.cli("board", "show", f.items[role]).output.splitlines() + assert "state: blocked" in lines and "human: REQUIRED" in lines + assert f" running → blocked [system] — {note}" in lines + # v0.1.2 blocked a crashed item without recording why on the item. + assert (f"blocked: {note}" in lines) is (release != "v0.1.2"), role + + +# ── decisions ───────────────────────────────────────────────────────────── + + +@pytest.mark.parametrize("release", RELEASES) +def test_decisions_read_as_the_release_did_and_stay_unbound(release, frozen): + f = frozen(release, "lifecycle") + board = f.board() + try: + for goal, expected in f.read["active_decisions"].items(): + got = board.active_decisions() if goal == "*" else board.active_decisions(goal=goal) + assert plain(got) == [_decision(d) for d in expected], goal + mapped = [plain(_row_to_decision(r)) + for r in f.rows("SELECT * FROM decisions ORDER BY rowid")] + assert mapped == [_decision(d) for d in f.read["decisions_mapped"]] + retired = [d for d in mapped if d["superseded_by"]] + assert [d["id"] for d in retired] == [f.decisions["superseded"]] + assert retired[0]["superseded_by"] == f.decisions["replacement"] + assert retired[0]["superseded_at"] is not None + # Legacy decisions are unbound: included for any project, never a + # project's lesson. (A project-bound lesson is excluded elsewhere: + # test_lessons.py covers the project filter with mixed rows.) + assert all(lesson_source(d) is None for d in board.active_decisions()) + assert [d.id for d in board.active_decisions(project_id="frozen-board")] == \ + [d["id"] for d in f.read["active_decisions"]["*"]] + assert board.project_lessons("frozen-board") == [] + assert board.project_lessons("frozen-board", goal="backend") == [] + finally: + board.close() + for goal, expected in f.read["active_decisions"].items(): + argv = ["board", "decisions"] + ([] if goal == "*" else ["--goal", goal]) + shown = f.cli(*argv) + assert shown.exit_code == 0, shown.output + assert shown.output == render_decisions( + [Decision(**_decision(d)) for d in expected]) + "\n" + # Written out from the release's read, not from render_decisions: one + # line per decision, oldest first, and no lesson line for any of them. + assert shown.output.splitlines() == ( + [f" {d['id']} [{d['scope'] or 'global'}] {d['text']}" for d in expected] + or ["[syncmill] no active decisions"]), goal + shown = f.cli("board", "decisions", "--goal", "backend").output + assert f" {f.decisions['scoped']} [backend] 백엔드는 SQLite를 유지한다." in shown.splitlines() + + +# ── stats ───────────────────────────────────────────────────────────────── + + +@pytest.mark.parametrize(("release", "scenario"), CASES) +def test_stats_read_as_the_release_did_at_every_clock(release, scenario, frozen): + f = frozen(release, scenario) + board = f.board() + try: + clocks = {"fresh": f.frozen_at, "aged": f.frozen_at + f.stall + 1} + for label, now in clocks.items(): + assert plain(board.stats(now=now)) == f.read["stats"][label], label + boundary = f.read.get("boundary") + if boundary: + stats = boundary["stats"] + # The probe straddles the aging cutoff, or it protects nothing. + assert stats["before"]["blocked_aged"] != stats["at"]["blocked_aged"] + for label, now in boundary["times"].items(): + assert plain(board.stats(now=now)) == stats[label], label + if scenario == "compacted": + assert f.read["stats"] == f.facts["before_compaction"]["stats"] + finally: + board.close() + for label, now in clocks.items(): + f.clock(now) + shown = f.cli("board", "stats") + assert shown.exit_code == 0, shown.output + expected = f.read["stats"][label] + assert shown.output == render_board_stats(BoardStats(**expected)) + "\n", label + # Literal counts, independent of render_board_stats. + lines = shown.output.splitlines() + assert lines[0] == f"items: {expected['total']}" + assert f" reclaimed (stale-lease): {expected['reclaimed_stale']}" in lines + for title, key in (("redispatched (work redone)", "redispatched"), + ("false-done (done, unverified)", "false_done"), + (f"blocked > {f.stall}s", "blocked_aged"), + (f"human-required > {f.stall}s", "human_required_aged"), + (f"dropped handoffs > {f.stall}s", "dropped_handoffs")): + found = [x for x in lines if x.startswith(f" {title}: ")] + assert len(found) == 1, (label, title, lines) + line = found[0] + assert line.split(": ")[1].split()[0] == str(len(expected[key])), (label, line) + for item_id in expected[key]: + assert item_id in line, (label, title) + by_state = " ".join(f"{s}={n}" for s, n in sorted(expected["by_state"].items())) + assert f" by state: {by_state}" in lines + + +@pytest.mark.parametrize("release", ["v0.2.0", "v0.3.0"]) +def test_compacted_counts_add_the_rollups_to_the_live_audit(release, frozen): + f = frozen(release, "compacted") + rolled, mixed = f.items["rolled"], f.items["mixed"] + rollups = {r["item_id"]: r["claim_count"] + for r in f.rows("SELECT * FROM transition_rollups")} + live = f.rows("SELECT item_id, note FROM transitions " + "WHERE from_state = 'planned' AND to_state = 'running'") + # Each count needs both sources: neither alone reaches it. + assert rollups[rolled] == 2 and rollups[mixed] == 1 + assert [r["item_id"] for r in live].count(mixed) == 1 + board = f.board() + try: + stats = board.stats(now=f.frozen_at) + finally: + board.close() + assert sorted(stats.redispatched) == sorted([rolled, mixed]) + assert stats.reclaimed_stale == 2 + assert " reclaimed (stale-lease): 2" in f.cli("board", "stats").output.splitlines() + + +# ── the human path on released rows ─────────────────────────────────────── + +_NO_VERIFICATION = ( + "Error: cannot mark item {} done without verification — attach passing " + "evidence (--evidence) or a human sign-off (--sign-off)" +) + + +@pytest.mark.parametrize("release", RELEASES) +def test_done_counts_the_evidence_a_release_recorded(release, frozen): + f = frozen(release, "lifecycle") + item_id = f.items["passed"] + done = f.cli("board", "update", item_id, "--state", "done") + assert done.exit_code == 0, done.output + board = f.board() + try: + item = board.get(item_id) + assert item.state == WorkState.DONE + assert plain(item.evidence) == f.read["items"][item_id]["evidence"] + last = board.transitions(item_id)[-1] + assert (last["from_state"], last["to_state"], last["actor"]) == ("review", "done", "human") + finally: + board.close() + + +@pytest.mark.parametrize("release", RELEASES) +@pytest.mark.parametrize("role", ["imported-1", "bare-done-refused", "route-gate-failed", + "pipeline-gate-failed"]) +def test_done_refuses_a_released_item_without_passing_evidence(release, role, frozen): + f = frozen(release, "lifecycle") + f.board().close() # migrate first, so the comparison is of this command alone + before = _cells(f.db) + refused = f.cli("board", "update", f.items[role], "--state", "done") + assert refused.exit_code == 1 + assert _last_line(refused) == _NO_VERIFICATION.format(f.items[role]) + assert _cells(f.db) == before + + +@pytest.mark.parametrize("release", RELEASES) +def test_human_updates_on_released_items_keep_what_they_do_not_change(release, frozen): + f = frozen(release, "lifecycle") + stamp = f.frozen_at + 10 + f.clock(stamp) + imported = f.items["imported-1"] + signed = f.cli("board", "update", imported, "--state", "done", "--sign-off") + assert signed.exit_code == 0, signed.output + board = f.board() + try: + item = board.get(imported) + assert item.state == WorkState.DONE + assert plain(item.evidence) == f.read["items"][imported]["evidence"] + [ + {"kind": "human", "ref": "sign-off", "passed": True, "at": stamp, "by": "human"}] + assert item.inputs == f.read["items"][imported]["inputs"] + finally: + board.close() + + +@pytest.mark.parametrize("release", RELEASES) +def test_clearing_human_required_keeps_a_released_crash_blocked(release, frozen): + f = frozen(release, "crash-blocked") + item_id = f.items["crashed"] + cleared = f.cli("board", "update", item_id, "--clear-human-required") + assert cleared.exit_code == 0, cleared.output + board = f.board() + try: + item = board.get(item_id) + finally: + board.close() + expected = {**f.read["items"][item_id], "human_required": False, + "updated_at": f.frozen_at} + assert plain(item) == expected + + +@pytest.mark.parametrize("release", RELEASES) +def test_annotating_a_released_running_item_keeps_its_lease(release, frozen): + f = frozen(release, "running") + item_id = f.items["killed"] + stamp = f.frozen_at + 5 + f.clock(stamp) + noted = f.cli("board", "update", item_id, "--evidence", "log://killed") + assert noted.exit_code == 0, noted.output + board = f.board() + try: + item = board.get(item_id) + history = board.transitions(item_id) + stats = board.stats(now=f.frozen_at) + finally: + board.close() + # An annotate is not a second claim. + assert stats.redispatched == f.read["stats"]["fresh"]["redispatched"] == [] + released = f.read["items"][item_id] + assert item.state == WorkState.RUNNING + assert item.lease_run_id == released["lease_run_id"] is not None + assert item.claimed_at == released["claimed_at"] + assert plain(item.evidence) == [ + {"kind": "manual", "ref": "log://killed", "passed": True, "at": stamp, "by": "human"}] + assert history[:-1] == f.read["transitions"][item_id] + assert (history[-1]["to_state"], history[-1]["note"]) == ("running", "annotated") + + +@pytest.mark.parametrize("release", RELEASES) +def test_a_released_decision_is_superseded_in_its_own_scope_only(release, frozen): + f = frozen(release, "lifecycle") + replacement = f.decisions["replacement"] + made = f.cli("board", "decide", "Spaces, four of them.", "--supersedes", replacement) + assert made.exit_code == 0, made.output + new_id = made.output.split("recorded decision ")[1].split()[0] + rows = {r["id"]: dict(r) for r in f.rows("SELECT * FROM decisions")} + assert rows[replacement]["superseded_by"] == new_id + assert rows[new_id]["project_id"] is None # inherits the released, unbound reach + f.board().close() + before = _cells(f.db) + for role, reason in ( + ("scoped", "it is scoped to 'backend', not '' — supersede only retires a " + "decision in the same scope"), + ("superseded", "it is already superseded"), + ): + refused = f.cli("board", "decide", "Something else.", "--supersedes", f.decisions[role]) + assert refused.exit_code == 1 + assert _last_line(refused) == f"Error: cannot supersede {f.decisions[role]}: {reason}" + assert _cells(f.db) == before + + +@pytest.mark.parametrize("release", RELEASES) +def test_reimporting_a_released_review_candidate_skips_it(release, frozen): + f = frozen(release, "lifecycle") + f.board().close() + before = _cells(f.db) + again = f.cli("board", "import-review-candidates", str(REPORT), "--goal", "review") + assert again.exit_code == 0, again.output + assert _last_line(again) == "[syncmill] imported 0 review candidate(s); skipped 1 existing" + other = f.cli("board", "import-review-candidates", str(REPORT), "--goal", "other") + assert _last_line(other) == ( + "[syncmill] imported 0 review candidate(s); skipped 1 existing " + "(1 kept their original goal)") + assert _cells(f.db) == before + + +def _evidence_with(row, **change) -> str: + evidence = json.loads(row["evidence"]) + evidence[0].update(change) + return json.dumps(evidence) + + +@pytest.mark.parametrize("release", RELEASES) +@pytest.mark.parametrize("change", [ + pytest.param(lambda row: ("task", row["task"] + " (edited)"), id="task"), + pytest.param(lambda row: ("inputs", json.dumps(json.loads(row["inputs"])[:4])), id="inputs"), + pytest.param(lambda row: ("evidence", _evidence_with(row, ref="sha256:" + "0" * 64)), + id="evidence-ref"), + pytest.param(lambda row: ("evidence", _evidence_with(row, by="someone")), id="evidence-by"), + pytest.param(lambda row: ("evidence", _evidence_with(row, kind="manual")), id="evidence-kind"), + pytest.param(lambda row: ("evidence", _evidence_with(row, passed=True)), id="evidence-passed"), +]) +def test_reimport_refuses_a_released_candidate_whose_provenance_differs( + release, change, frozen +): + # The item id is a uuid5 of the provenance, so only a stored row that no + # longer matches it can collide; each checked component is changed alone. + f = frozen(release, "lifecycle") + f.board().close() + item_id = f.items["imported-1"] + row = f.rows("SELECT * FROM work_items WHERE id = ?", item_id)[0] + column, value = change(row) + conn = sqlite3.connect(f.db) + with conn: + conn.execute(f"UPDATE work_items SET {column} = ? WHERE id = ?", (value, item_id)) + conn.close() + before = _cells(f.db) + refused = f.cli("board", "import-review-candidates", str(REPORT), "--goal", "review") + assert refused.exit_code == 1 + assert _last_line(refused) == f"Error: review-candidate provenance collision for item {item_id}" + assert _cells(f.db) == before