shikiru-cli 0.2.0__py3-none-any.whl

shikiru/store/events.py

@@ -0,0 +1,213 @@
+"""Event log: append typed events, read them back since an id."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import TypeAdapter
+
+from shikiru.domain.commands import COMMAND_ID_KEY
+from shikiru.domain.events import Event, EventKind
+from shikiru.domain.tasks import Role
+from shikiru.store.database import (
+    dump_json,
+    format_timestamp,
+    load_json,
+    parse_required_timestamp,
+    require_after_insert,
+)
+
+if TYPE_CHECKING:
+    import sqlite3  # noqa: TID251
+    from collections.abc import Sequence
+
+    from shikiru.clock import Clock
+
+_EVENT_ROLE_JSON_PATH = "$.role"
+_EVENT_TURN_JSON_PATH = "$.turn"
+_EVENT_COMMAND_JSON_PATH = f"$.{COMMAND_ID_KEY}"
+MAX_TIMELINE_EVENT_LIMIT = 50
+
+COMMAND_APPLIED_SQL = "SELECT 1 FROM events WHERE kind = ? AND json_extract(data, ?) = ? LIMIT 1"
+
+_DATA_ADAPTER: TypeAdapter[dict[str, Any]] = TypeAdapter(dict[str, Any])
+
+
+def _row_to_event(row: sqlite3.Row) -> Event:
+    return Event(
+        id=row["id"],
+        ts=parse_required_timestamp(row["ts"]),
+        task_id=row["task_id"],
+        kind=EventKind(row["kind"]),
+        message=row["message"],
+        data=load_json(_DATA_ADAPTER, row["data"]),
+    )
+
+
+def fetch_events_since(
+    connection: sqlite3.Connection,
+    since_id: int,
+    *,
+    kinds: Sequence[EventKind] | None = None,
+    task_id: str | None = None,
+) -> list[Event]:
+    """Read every event with `id > since_id`, optionally filtered by `kinds` and `task_id`."""
+    clauses = ["id > ?"]
+    params: list[object] = [since_id]
+    if kinds:
+        placeholders = ", ".join("?" for _ in kinds)
+        clauses.append(f"kind IN ({placeholders})")
+        params.extend(kind.value for kind in kinds)
+    if task_id is not None:
+        clauses.append("task_id = ?")
+        params.append(task_id)
+    where = " AND ".join(clauses)
+    rows = connection.execute(
+        f"SELECT id, ts, task_id, kind, message, data FROM events WHERE {where} ORDER BY id",
+        params,
+    ).fetchall()
+    return [_row_to_event(row) for row in rows]
+
+
+def fetch_latest_events(
+    connection: sqlite3.Connection,
+    limit: int,
+    *,
+    kinds: Sequence[EventKind] | None = None,
+    implementer_turns_only: bool = False,
+    task_id: str | None = None,
+) -> list[Event]:
+    """Read the latest matching events in chronological order."""
+    if limit < 1:
+        message = "event limit must be positive"
+        raise ValueError(message)
+    clauses: list[str] = []
+    params: list[object] = []
+    if kinds:
+        placeholders = ", ".join("?" for _ in kinds)
+        clauses.append(f"kind IN ({placeholders})")
+        params.extend(kind.value for kind in kinds)
+    if task_id is not None:
+        clauses.append("task_id = ?")
+        params.append(task_id)
+    if implementer_turns_only:
+        clauses.append("(kind != ? OR json_extract(data, ?) = ?)")
+        params.extend(
+            (EventKind.TURN_COMPLETED.value, _EVENT_ROLE_JSON_PATH, Role.IMPLEMENTER.value)
+        )
+    where = f"WHERE {' AND '.join(clauses)} " if clauses else ""
+    rows = connection.execute(
+        f"SELECT id, ts, task_id, kind, message, data FROM events {where}ORDER BY id DESC LIMIT ?",
+        [*params, limit],
+    ).fetchall()
+    return [_row_to_event(row) for row in reversed(rows)]
+
+
+def fetch_timeline_events(
+    connection: sqlite3.Connection,
+    task_id: str,
+    *,
+    limit: int,
+    before: tuple[str, int] | None = None,
+    kinds: Sequence[EventKind] | None = None,
+    role: str | None = None,
+    turn: str | None = None,
+) -> list[Event]:
+    """Read one newest-first, keyset-paginated task event page with SQL filters."""
+    if not 0 < limit <= MAX_TIMELINE_EVENT_LIMIT:
+        message = f"task timeline event limit must be between 1 and {MAX_TIMELINE_EVENT_LIMIT}"
+        raise ValueError(message)
+    if kinds is not None and not kinds:
+        return []
+    clauses = ["task_id = ?"]
+    params: list[object] = [task_id]
+    if before is not None:
+        clauses.append("(ts < ? OR (ts = ? AND id < ?))")
+        params.extend((before[0], before[0], before[1]))
+    if kinds is not None:
+        placeholders = ", ".join("?" for _ in kinds)
+        clauses.append(f"kind IN ({placeholders})")
+        params.extend(kind.value for kind in kinds)
+    if role is not None:
+        clauses.append("json_extract(data, ?) = ?")
+        params.extend((_EVENT_ROLE_JSON_PATH, role))
+    if turn is not None:
+        clauses.append("json_extract(data, ?) = ?")
+        params.extend((_EVENT_TURN_JSON_PATH, turn))
+    where = " AND ".join(clauses)
+    rows = connection.execute(
+        f"SELECT id, ts, task_id, kind, message, data FROM events WHERE {where} "
+        "ORDER BY ts DESC, id DESC LIMIT ?",
+        [*params, limit],
+    ).fetchall()
+    return [_row_to_event(row) for row in rows]
+
+
+class EventLog:
+    """Appends typed events and reads them back since an id (`domain.events`)."""
+
+    def __init__(self, connection: sqlite3.Connection, clock: Clock) -> None:
+        """Use `connection` (the engine's writer) and `clock` for every append below."""
+        self._connection = connection
+        self._clock = clock
+
+    def append(
+        self,
+        kind: EventKind,
+        *,
+        message: str,
+        task_id: str | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> Event:
+        """Append one event and return it with its allocated id and timestamp."""
+        ts = self._clock.now()
+        event_data = data if data is not None else {}
+        cursor = self._connection.execute(
+            "INSERT INTO events (ts, task_id, kind, message, data) VALUES (?, ?, ?, ?, ?)",
+            (
+                format_timestamp(ts),
+                task_id,
+                kind.value,
+                message,
+                dump_json(_DATA_ADAPTER, event_data),
+            ),
+        )
+        event_id = require_after_insert(
+            cursor.lastrowid, "sqlite did not allocate a rowid for the new event"
+        )
+        return Event(
+            id=event_id, ts=ts, task_id=task_id, kind=kind, message=message, data=event_data
+        )
+
+    def since(
+        self,
+        since_id: int,
+        *,
+        kinds: Sequence[EventKind] | None = None,
+        task_id: str | None = None,
+    ) -> list[Event]:
+        """Read every event since `since_id`, optionally filtered by `kinds` and `task_id`."""
+        return fetch_events_since(self._connection, since_id, kinds=kinds, task_id=task_id)
+
+    def latest(
+        self,
+        limit: int,
+        *,
+        kinds: Sequence[EventKind] | None = None,
+        task_id: str | None = None,
+    ) -> list[Event]:
+        """Read the latest matching events in chronological order."""
+        return fetch_latest_events(self._connection, limit, kinds=kinds, task_id=task_id)
+
+    def command_applied(self, kind: EventKind, command_id: int) -> bool:
+        """Report whether a `kind` event already records the effect of command `command_id`."""
+        row = self._connection.execute(
+            COMMAND_APPLIED_SQL,
+            (kind.value, _EVENT_COMMAND_JSON_PATH, command_id),
+        ).fetchone()
+        return row is not None
+
+    def latest_id(self) -> int:
+        """Return the current event cursor, or zero when the log is empty."""
+        row = self._connection.execute("SELECT COALESCE(MAX(id), 0) FROM events").fetchone()
+        return int(row[0])

shikiru/store/feedback.py

@@ -0,0 +1,266 @@
+"""The durable progress of PR feedback rounds and of the replies they owe."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from shikiru.domain.feedback import FeedbackSnapshot, FeedbackSourceKind
+from shikiru.domain.feedback_rounds import (
+    UNFINISHED_STAGES,
+    FeedbackReply,
+    FeedbackRound,
+    FeedbackStage,
+    ReplyState,
+)
+from shikiru.domain.reports import FeedbackAnalysis
+from shikiru.store.database import transaction
+
+if TYPE_CHECKING:
+    import sqlite3  # noqa: TID251
+    from collections.abc import Sequence
+
+_ROUND_COLUMNS = (
+    "id, task_id, pull_request_url, review_ids, snapshot, stage, analysis, attempts, blocked, "
+    " expected_remote_sha, verified_sha, published_sha, checks, verified_replies"
+)
+_REPLY_COLUMNS = "round_id, source_id, kind, marker, body, state, posted_url"
+_UNFINISHED = tuple(stage.value for stage in sorted(UNFINISHED_STAGES))
+
+
+class FeedbackStore:
+    """Stores, per task, the feedback rounds of its pull request and each round's replies."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        """Use `connection`, the engine's writer."""
+        self._connection = connection
+
+    def start(
+        self,
+        *,
+        task_id: str,
+        pull_request_url: str,
+        review_ids: Sequence[str],
+        comment_ids: Sequence[str],
+        snapshot: FeedbackSnapshot,
+        expected_remote_sha: str,
+    ) -> FeedbackRound:
+        """Record a new round over `snapshot`, starting at its analysis."""
+        with transaction(self._connection):
+            cursor = self._connection.execute(
+                "INSERT INTO feedback_rounds "
+                "(task_id, pull_request_url, review_ids, snapshot, stage, expected_remote_sha) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (
+                    task_id,
+                    pull_request_url,
+                    json.dumps(list(review_ids)),
+                    snapshot.model_dump_json(),
+                    FeedbackStage.ANALYSIS.value,
+                    expected_remote_sha,
+                ),
+            )
+            round_id = _row_id(cursor)
+            self._connection.executemany(
+                "INSERT INTO feedback_round_comments (round_id, comment_id) VALUES (?, ?)",
+                [(round_id, comment_id) for comment_id in comment_ids],
+            )
+        return self._require(round_id)
+
+    def active(self, task_id: str) -> FeedbackRound | None:
+        """Return `task_id`'s unfinished round, if it has one."""
+        row = self._connection.execute(
+            f"SELECT {_ROUND_COLUMNS} FROM feedback_rounds WHERE task_id = ? "
+            f"AND stage IN ({_marks(_UNFINISHED)}) ORDER BY id LIMIT 1",
+            (task_id, *_UNFINISHED),
+        ).fetchone()
+        return None if row is None else self._load(row)
+
+    def last_pull_request_url(self, task_id: str) -> str | None:
+        """Return the pull request of `task_id`'s latest round, or `None` without any round."""
+        row = self._connection.execute(
+            "SELECT pull_request_url FROM feedback_rounds WHERE task_id = ? "
+            "ORDER BY id DESC LIMIT 1",
+            (task_id,),
+        ).fetchone()
+        return None if row is None else str(row["pull_request_url"])
+
+    def seen_review_ids(self, task_id: str, pull_request_url: str) -> set[str]:
+        """Return every review a round of `task_id` on `pull_request_url` was started for."""
+        rows = self._connection.execute(
+            "SELECT review_ids FROM feedback_rounds WHERE task_id = ? AND pull_request_url = ?",
+            (task_id, pull_request_url),
+        ).fetchall()
+        return {review for row in rows for review in json.loads(row["review_ids"])}
+
+    def seen_comment_ids(self, task_id: str, pull_request_url: str) -> set[str]:
+        """Return every discussion comment a round of `task_id` on `pull_request_url` covered."""
+        rows = self._connection.execute(
+            "SELECT comment_id FROM feedback_round_comments WHERE round_id IN "
+            "(SELECT id FROM feedback_rounds WHERE task_id = ? AND pull_request_url = ?)",
+            (task_id, pull_request_url),
+        ).fetchall()
+        return {str(row["comment_id"]) for row in rows}
+
+    def set_stage(self, round_id: int, stage: FeedbackStage) -> None:
+        """Move the round to `stage`."""
+        self._set(round_id, "stage", stage.value)
+
+    def save_analysis(
+        self, round_id: int, analysis: FeedbackAnalysis, stage: FeedbackStage
+    ) -> None:
+        """Keep the Leader's `analysis` and move the round to `stage`."""
+        with transaction(self._connection):
+            self._set(round_id, "analysis", analysis.model_dump_json())
+            self._set(round_id, "stage", stage.value)
+
+    def complete_implementation(self, round_id: int, attempts: int, checks: str) -> None:
+        """Atomically record a completed rework and advance to verification."""
+        with transaction(self._connection):
+            self._set(round_id, "checks", checks)
+            self._set(round_id, "attempts", attempts)
+            self._set(round_id, "stage", FeedbackStage.VERIFICATION.value)
+
+    def set_blocked(self, round_id: int, *, blocked: bool) -> None:
+        """Record whether the round waits for the Operator."""
+        self._set(round_id, "blocked", int(blocked))
+
+    def reset_after_retry(self, round_id: int, stage: FeedbackStage) -> None:
+        """Clear the block and the attempts of a retried round and resume it at `stage`."""
+        with transaction(self._connection):
+            self._set(round_id, "blocked", 0)
+            self._set(round_id, "attempts", 0)
+            self._set(round_id, "stage", stage.value)
+
+    def save_verified(
+        self,
+        round_id: int,
+        *,
+        sha: str,
+        replies: dict[str, str],
+        stage: FeedbackStage,
+        planned: Sequence[FeedbackReply] = (),
+    ) -> None:
+        """Record the tip and replies the Leader verified, with any `planned` replies owed now.
+
+        The verification, the planned replies and the move to `stage` commit together.
+        """
+        with transaction(self._connection):
+            self._set(round_id, "verified_sha", sha)
+            self._set(round_id, "verified_replies", json.dumps(replies))
+            self._insert_replies(planned)
+            self._set(round_id, "stage", stage.value)
+
+    def set_expected_remote(self, round_id: int, sha: str) -> None:
+        """Record the remote head the round's push may overwrite."""
+        self._set(round_id, "expected_remote_sha", sha)
+
+    def save_published(self, round_id: int, sha: str) -> None:
+        """Record the commit published to the remote branch."""
+        self._set(round_id, "published_sha", sha)
+
+    def plan_replies(self, round_id: int, replies: Sequence[FeedbackReply]) -> None:
+        """Store the replies the round owes, keeping any already stored, and move to sending."""
+        with transaction(self._connection):
+            self._insert_replies(replies)
+            self._set(round_id, "stage", FeedbackStage.REPLIES.value)
+
+    def replies(self, round_id: int) -> list[FeedbackReply]:
+        """Return the round's replies in the order they were planned."""
+        rows = self._connection.execute(
+            f"SELECT {_REPLY_COLUMNS} FROM feedback_replies WHERE round_id = ? ORDER BY rowid",
+            (round_id,),
+        ).fetchall()
+        return [_reply(row) for row in rows]
+
+    def set_reply_state(
+        self, round_id: int, source_id: str, state: ReplyState, posted_url: str | None = None
+    ) -> None:
+        """Record how far the reply to `source_id` got."""
+        self._connection.execute(
+            "UPDATE feedback_replies SET state = ?, posted_url = COALESCE(?, posted_url) "
+            "WHERE round_id = ? AND source_id = ?",
+            (state.value, posted_url, round_id, source_id),
+        )
+
+    def _insert_replies(self, replies: Sequence[FeedbackReply]) -> None:
+        for reply in replies:
+            self._connection.execute(
+                f"INSERT OR IGNORE INTO feedback_replies ({_REPLY_COLUMNS}) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (
+                    reply.round_id,
+                    reply.source_id,
+                    reply.kind.value,
+                    reply.marker,
+                    reply.body,
+                    reply.state.value,
+                    reply.posted_url,
+                ),
+            )
+
+    def _require(self, round_id: int) -> FeedbackRound:
+        row = self._connection.execute(
+            f"SELECT {_ROUND_COLUMNS} FROM feedback_rounds WHERE id = ?", (round_id,)
+        ).fetchone()
+        if row is None:
+            message = f"feedback round {round_id} vanished"
+            raise LookupError(message)
+        return self._load(row)
+
+    def _load(self, row: sqlite3.Row) -> FeedbackRound:
+        comments = self._connection.execute(
+            "SELECT comment_id FROM feedback_round_comments WHERE round_id = ? ORDER BY rowid",
+            (row["id"],),
+        ).fetchall()
+        return _round(row, [str(comment["comment_id"]) for comment in comments])
+
+    def _set(self, round_id: int, column: str, value: str | int) -> None:
+        self._connection.execute(
+            f"UPDATE feedback_rounds SET {column} = ? WHERE id = ?", (value, round_id)
+        )
+
+
+def _row_id(cursor: sqlite3.Cursor) -> int:
+    row_id = cursor.lastrowid
+    if row_id is None:
+        message = "inserted feedback round has no row id"
+        raise LookupError(message)
+    return row_id
+
+
+def _marks(values: Sequence[str]) -> str:
+    return ", ".join("?" for _ in values)
+
+
+def _round(row: sqlite3.Row, comment_ids: list[str]) -> FeedbackRound:
+    analysis = row["analysis"]
+    return FeedbackRound(
+        id=row["id"],
+        task_id=row["task_id"],
+        pull_request_url=row["pull_request_url"],
+        review_ids=json.loads(row["review_ids"]),
+        comment_ids=comment_ids,
+        snapshot=FeedbackSnapshot.model_validate_json(row["snapshot"]),
+        stage=FeedbackStage(row["stage"]),
+        analysis=None if analysis is None else FeedbackAnalysis.model_validate_json(analysis),
+        attempts=row["attempts"],
+        blocked=bool(row["blocked"]),
+        expected_remote_sha=row["expected_remote_sha"],
+        verified_sha=row["verified_sha"],
+        published_sha=row["published_sha"],
+        checks=row["checks"],
+        verified_replies=json.loads(row["verified_replies"]),
+    )
+
+
+def _reply(row: sqlite3.Row) -> FeedbackReply:
+    return FeedbackReply(
+        round_id=row["round_id"],
+        source_id=row["source_id"],
+        kind=FeedbackSourceKind(row["kind"]),
+        marker=row["marker"],
+        body=row["body"],
+        state=ReplyState(row["state"]),
+        posted_url=row["posted_url"],
+    )

shikiru/store/migrations/001_initial.sql

@@ -0,0 +1,63 @@
+CREATE TABLE sequences (name TEXT PRIMARY KEY, value INTEGER NOT NULL);
+
+CREATE TABLE tasks (
+  id TEXT PRIMARY KEY, seq INTEGER UNIQUE NOT NULL,
+  parent_id TEXT REFERENCES tasks(id), origin TEXT NOT NULL,
+  title TEXT NOT NULL, request TEXT NOT NULL,
+  mode TEXT, complexity TEXT NOT NULL DEFAULT 'normal', priority INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL, step TEXT, status_reason TEXT,
+  holds TEXT NOT NULL DEFAULT '[]',
+  iteration INTEGER NOT NULL DEFAULT 0,
+  counters TEXT NOT NULL DEFAULT '{}',
+  rung_index TEXT NOT NULL DEFAULT '{}',
+  overrides TEXT NOT NULL DEFAULT '{}',
+  repo TEXT,
+  slot INTEGER, window_id TEXT, panes TEXT NOT NULL DEFAULT '{}',
+  wait_reason TEXT, requeued_at TEXT, summary TEXT,
+  created_at TEXT NOT NULL, started_at TEXT, finished_at TEXT
+);
+
+CREATE INDEX idx_tasks_status ON tasks(status);
+
+CREATE TABLE task_deps (task_id TEXT NOT NULL REFERENCES tasks(id), depends_on TEXT NOT NULL REFERENCES tasks(id),
+  PRIMARY KEY (task_id, depends_on));
+
+CREATE INDEX idx_task_deps_depends_on ON task_deps(depends_on);
+
+CREATE TABLE runs (
+  id INTEGER PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks(id), role TEXT NOT NULL,
+  agent TEXT NOT NULL, model TEXT NOT NULL, effort TEXT,
+  session_id TEXT, resume_command TEXT,
+  agent_state TEXT NOT NULL DEFAULT '{}', last_message TEXT,
+  status TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0, cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL, cost_basis TEXT, context_used_pct REAL,
+  started_at TEXT NOT NULL, ended_at TEXT
+);
+
+CREATE INDEX idx_runs_task_id ON runs(task_id);
+
+CREATE TABLE agent_blocks (agent TEXT PRIMARY KEY, until TEXT NOT NULL, reason TEXT NOT NULL);
+CREATE TABLE quotas (agent TEXT NOT NULL, window TEXT NOT NULL, used_pct REAL NOT NULL, resets_at TEXT,
+  observed_at TEXT NOT NULL, PRIMARY KEY (agent, window));
+
+CREATE TABLE escalations (
+  id TEXT PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks(id), step TEXT, reason TEXT NOT NULL,
+  headline TEXT NOT NULL, packet_path TEXT NOT NULL, options TEXT NOT NULL,
+  status TEXT NOT NULL,
+  resolution TEXT, created_at TEXT NOT NULL, resolved_at TEXT
+);
+
+CREATE INDEX idx_escalations_status ON escalations(status);
+
+CREATE TABLE events (id INTEGER PRIMARY KEY, ts TEXT NOT NULL, task_id TEXT, kind TEXT NOT NULL,
+  message TEXT NOT NULL, data TEXT NOT NULL DEFAULT '{}');
+
+CREATE INDEX idx_events_task_id ON events(task_id);
+
+CREATE TABLE commands (id INTEGER PRIMARY KEY, ts TEXT NOT NULL, kind TEXT NOT NULL, payload TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  result TEXT, handled_at TEXT);
+
+CREATE INDEX idx_commands_status ON commands(status);

shikiru/store/migrations/002_headless_turns.sql

@@ -0,0 +1,31 @@
+DROP INDEX idx_runs_task_id;
+
+ALTER TABLE runs RENAME TO runs_legacy;
+
+CREATE TABLE runs (
+  id INTEGER PRIMARY KEY, task_id TEXT NOT NULL REFERENCES tasks(id), role TEXT NOT NULL,
+  agent TEXT NOT NULL, model TEXT NOT NULL, effort TEXT,
+  session_id TEXT, resume_command TEXT, last_message TEXT,
+  status TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0, cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL, cost_basis TEXT NOT NULL DEFAULT 'unknown', context_used_pct REAL,
+  started_at TEXT NOT NULL, ended_at TEXT
+);
+
+INSERT INTO runs (
+  id, task_id, role, agent, model, effort, session_id, resume_command, last_message,
+  status,
+  input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_usd, cost_basis,
+  context_used_pct, started_at, ended_at
+)
+SELECT
+  id, task_id, role, agent, model, effort, session_id, resume_command, last_message,
+  CASE WHEN status = 'exited' THEN 'closed' ELSE status END,
+  input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, cost_usd,
+  COALESCE(cost_basis, 'unknown'), context_used_pct, started_at, ended_at
+FROM runs_legacy;
+
+DROP TABLE runs_legacy;
+
+CREATE INDEX idx_runs_task_id ON runs(task_id);

shikiru/store/migrations/003_drop_command_handled_at.sql

@@ -0,0 +1 @@
+ALTER TABLE commands DROP COLUMN handled_at;

shikiru/store/migrations/004_repo_base_ref.sql

@@ -0,0 +1,3 @@
+UPDATE tasks
+SET repo = json_set(repo, '$.base_ref', json_extract(repo, '$.base'))
+WHERE repo IS NOT NULL AND json_extract(repo, '$.base_ref') IS NULL

shikiru/store/migrations/005_complexity_explicit.sql

@@ -0,0 +1,3 @@
+ALTER TABLE tasks ADD COLUMN complexity_explicit INTEGER NOT NULL DEFAULT 0;
+
+UPDATE tasks SET complexity_explicit = 1 WHERE complexity != 'normal'

shikiru/store/migrations/006_events_kind_index.sql

@@ -0,0 +1 @@
+CREATE INDEX idx_events_kind ON events(kind)

shikiru/store/migrations/007_notification_cursor.sql

@@ -0,0 +1 @@
+CREATE TABLE notification_cursor (id INTEGER PRIMARY KEY CHECK (id = 1), event_id INTEGER NOT NULL)

shikiru/store/migrations/008_reported_usage.sql

@@ -0,0 +1 @@
+ALTER TABLE runs ADD COLUMN usage_reported INTEGER;

shikiru/store/migrations/009_billing_declarations.sql

@@ -0,0 +1,2 @@
+ALTER TABLE runs ADD COLUMN billing_mode TEXT NOT NULL DEFAULT 'unknown';
+ALTER TABLE runs ADD COLUMN billing_source TEXT NOT NULL DEFAULT 'unknown';

shikiru/store/migrations/010_canonical_quota_windows.sql

@@ -0,0 +1,3 @@
+DELETE FROM quotas
+WHERE (agent = 'claude' AND window IN ('five_hour', 'seven_day'))
+   OR (agent = 'codex' AND window IN ('primary', 'secondary'));

shikiru/store/migrations/012_drop_task_quota_evidence.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS task_quota_samples;
+DROP TABLE IF EXISTS task_quota_turns;

shikiru/store/migrations/013_push_targets.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS push_targets (
+    base TEXT PRIMARY KEY,
+    registered INTEGER NOT NULL,
+    pushed INTEGER NOT NULL,
+    due_at TEXT,
+    last_pushed_at TEXT
+)

shikiru/store/migrations/014_agent_block_time.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS agent_block_times (
+    agent TEXT PRIMARY KEY,
+    blocked_at TEXT NOT NULL
+);
+INSERT OR IGNORE INTO agent_block_times (agent, blocked_at)
+SELECT agent, strftime('%Y-%m-%dT%H:%M:%f000+00:00', 'now') FROM agent_blocks

shikiru/store/migrations/015_repair_orphan_agent_blocks.sql

@@ -0,0 +1,3 @@
+DELETE FROM agent_block_times WHERE agent NOT IN (SELECT agent FROM agent_blocks);
+INSERT OR IGNORE INTO agent_block_times (agent, blocked_at)
+SELECT agent, strftime('%Y-%m-%dT%H:%M:%f000+00:00', 'now') FROM agent_blocks

shikiru/store/migrations/016_feedback_rounds.sql

@@ -0,0 +1,29 @@
+CREATE TABLE IF NOT EXISTS feedback_rounds (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id TEXT NOT NULL,
+    pull_request_url TEXT NOT NULL,
+    review_ids TEXT NOT NULL,
+    snapshot TEXT NOT NULL,
+    stage TEXT NOT NULL,
+    analysis TEXT,
+    attempts INTEGER NOT NULL DEFAULT 0,
+    blocked INTEGER NOT NULL DEFAULT 0,
+    expected_remote_sha TEXT NOT NULL,
+    verified_sha TEXT,
+    published_sha TEXT,
+    checks TEXT NOT NULL DEFAULT '',
+    verified_replies TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS feedback_rounds_task ON feedback_rounds (task_id, pull_request_url);
+
+CREATE TABLE IF NOT EXISTS feedback_replies (
+    round_id INTEGER NOT NULL REFERENCES feedback_rounds(id),
+    source_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    marker TEXT NOT NULL,
+    body TEXT NOT NULL,
+    state TEXT NOT NULL,
+    posted_url TEXT,
+    PRIMARY KEY (round_id, source_id)
+);

shikiru/store/migrations/017_feedback_round_comments.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS feedback_round_comments (
+    round_id INTEGER NOT NULL REFERENCES feedback_rounds(id),
+    comment_id TEXT NOT NULL,
+    PRIMARY KEY (round_id, comment_id)
+);

shikiru/store/migrations/__init__.py

@@ -0,0 +1 @@
+"""Packaged SQL migrations, applied in ascending filename order."""