refactor(supervise): drop obsolete queue helpers (archive_proposal, wait_for_response, audit_dir/path)

Remove the supervise queue helpers that no live path uses anymore — they're
mechanisms the PRD-0070 / idempotent-poll migration superseded:

  - archive_proposal (+ QueueStore.archive_proposal): the poll stopped archiving
    on read (#469 review), so single-proposal archiving has no caller; decided
    proposals drop off the pending list via their response row and are reaped in
    bulk by archive_all_proposals on teardown/reconcile.
  - wait_for_response: the data plane polls the queue over the control-plane RPC
    now, so nothing block-waits on it.
  - audit_dir / audit_log_path: file-based audit paths, replaced by the SQLite
    AuditStore.

Also drops the tests that covered those obsolete helpers. Kept the prod-unused
read accessors list_pending_proposals and read_audit_entries: those aren't dead
mechanisms — they're the read side of live write paths that many tests use to
verify real queue/audit behavior.

Full unit suite green (2243).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

bot_bottle/orchestrator/store/queue_store.py

@@ -167,25 +167,6 @@ class QueueStore(DbStore):
             raise FileNotFoundError(proposal_id)
         return self._row_to_response(row)
 
-    def archive_proposal(self, proposal_id: str) -> None:
-        if not self.db_path.is_file():
-            return
-        with self._connection() as conn:
-            conn.execute(
-                """
-                UPDATE supervise_proposals SET archived = 1
-                WHERE queue_key = ? AND id = ?
-                """,
-                (self.queue_key, proposal_id),
-            )
-            conn.execute(
-                """
-                UPDATE supervise_responses SET archived = 1
-                WHERE queue_key = ? AND proposal_id = ?
-                """,
-                (self.queue_key, proposal_id),
-            )
-
     def archive_all(self) -> None:
         """Archive every proposal + response for this queue key. Used to reap a
         bottle's supervise records when it is torn down or reconciled away —

bot_bottle/orchestrator/supervisor/__init__.py

@@ -20,9 +20,6 @@ from ...supervisor.plan import SupervisePlan
 from ..store.store_manager import StoreManager
 from .queue import (
     archive_all_proposals,
-    archive_proposal,
-    audit_dir,
-    audit_log_path,
     list_all_pending_proposals,
     list_pending_proposals,
     read_audit_entries,
@@ -30,7 +27,6 @@ from .queue import (
     read_response,
     render_diff,
     sha256_hex,
-    wait_for_response,
     write_audit_entry,
     write_proposal,
     write_response,

bot_bottle/orchestrator/supervisor/queue.py

@@ -11,31 +11,13 @@ from __future__ import annotations
 
 import difflib
 import hashlib
-import time
 from pathlib import Path
 
-from ...supervisor.types import (
-    AuditEntry,
-    DEFAULT_POLL_INTERVAL_SEC,
-    Proposal,
-    Response,
-)
-from ...paths import bot_bottle_root
+from ...supervisor.types import AuditEntry, Proposal, Response
 from ..store.queue_store import QueueStore
 from ...store.audit_store import AuditStore
 
 
-# --- Paths -----------------------------------------------------------------
-
-
-def audit_dir() -> Path:
-    return bot_bottle_root() / "audit"
-
-
-def audit_log_path(component: str, slug: str) -> Path:
-    return audit_dir() / f"{component}-{slug}.log"
-
-
 # --- Queue I/O -------------------------------------------------------------
 
 
@@ -69,36 +51,6 @@ def read_response(bottle_slug: str, proposal_id: str) -> Response:
     return QueueStore(bottle_slug).read_response(proposal_id)
 
 
-def wait_for_response(
-    bottle_slug: str,
-    proposal_id: str,
-    *,
-    poll_interval: float = DEFAULT_POLL_INTERVAL_SEC,
-    deadline: float | None = None,
-) -> Response:
-    """Block until a response file appears for `proposal_id`, then return it.
-    `deadline` is an absolute time.monotonic() value after which the wait raises
-    TimeoutError. None waits forever — the natural shape, since the operator's
-    response time is unbounded.
-
-    Polls SQLite so the implementation stays portable and stdlib-only."""
-    store = QueueStore(bottle_slug)
-    while True:
-        try:
-            return store.read_response(proposal_id)
-        except FileNotFoundError:
-            pass
-        if deadline is not None and time.monotonic() >= deadline:
-            raise TimeoutError(f"no response for proposal {proposal_id!r}")
-        time.sleep(poll_interval)
-
-
-def archive_proposal(bottle_slug: str, proposal_id: str) -> None:
-    """Mark both proposal and response rows processed.
-    Idempotent — missing rows are silently skipped."""
-    QueueStore(bottle_slug).archive_proposal(proposal_id)
-
-
 def archive_all_proposals(bottle_slug: str) -> None:
     """Archive every proposal + response for `bottle_slug` (bottle teardown /
     reconcile cleanup). Idempotent."""