sbxloop 0.7.2__tar.gz → 0.7.4__tar.gz

{sbxloop-0.7.2 → sbxloop-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sbxloop
-Version: 0.7.2
+Version: 0.7.4
 Summary: Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains
 Project-URL: Homepage, https://github.com/brettbergin/sbxloop
 Project-URL: Repository, https://github.com/brettbergin/sbxloop

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.2'
-__version_tuple__ = version_tuple = (0, 7, 2)
+__version__ = version = '0.7.4'
+__version_tuple__ = version_tuple = (0, 7, 4)
 
 __commit_id__ = commit_id = None

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/cli/app.py

@@ -1477,6 +1477,14 @@ def daemon(
     if config.daemon.backlog == "github" and not github_active:
         console.print("[bold red]--backlog github needs a GitHub repository[/] (--repo).")
         raise typer.Exit(2)
+    if github_active and config.daemon.backlog != "github":
+        # The audit lane is always on when issues are a source; its
+        # findings only have somewhere to go with backlog = "github".
+        console.print(
+            f"[yellow]note:[/] audit issues (`{config.daemon.audit_label}`) file their "
+            "findings as backlog issues, which needs [cyan]--backlog github[/]; with "
+            f"backlog={config.daemon.backlog!r} an audit run completes but files nothing."
+        )
 
     # Say where the state went: with the anchored default, `sbxloop status`
     # in the runner dir shows nothing unless SBXLOOP_STATE_DIR points here.
@@ -1500,6 +1508,7 @@ def daemon(
             config.daemon.failed_label,
             config.daemon.backlog_label,
             config.daemon.delivered_label,
+            config.daemon.audit_label,
         )
         sources.append(
             GitHubIssueSource(
@@ -1508,6 +1517,7 @@ def daemon(
                 labels,
                 on_failure=github.note_failure,
                 close_on_success=config.daemon.close_on_success,
+                tool_repo=config.daemon.tool_repo,
             )
         )
 
@@ -1998,6 +2008,14 @@ mem_abort = 0.0
 # failed_label = "sbxloop:failed"
 # backlog_label = "sbxloop:backlog"
 # delivered_label = "sbxloop:delivered"
+# audit_label = "sbxloop:audit"    # discovery lane: investigate, file findings, no PR
+# postmortems = true             # file a post-mortem audit when a patch item fails
+# postmortems_per_day = 3
+# audits = false                 # open .github/sbxloop/audits/*.md charters on schedule
+# review_deliveries = true       # audit each PR the loop delivers (defects → backlog)
+# reviews_per_day = 5
+# tool_repo = "brettbergin/sbxloop"  # findings ABOUT sbxloop go here, never to the project
+# audit_dir = ".github/sbxloop/audits"
 # What a delivered run does to the tracker. Defaults are task-queue
 # semantics: close the source issue (the PR is the reviewable object) and
 # open a per-run tracking issue. For a design/discussion tracker set both

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/config.py

@@ -361,6 +361,30 @@ class DaemonConfig(_ConfigModel):
     failed_label: str = "sbxloop:failed"
     backlog_label: str = "sbxloop:backlog"
     delivered_label: str = "sbxloop:delivered"
+    # Discovery lane: an issue carrying this label is a charter — the run
+    # investigates and files findings as backlog issues, never a PR.
+    audit_label: str = "sbxloop:audit"
+    # When a patch item is abandoned (or delivers nothing), file a post-mortem
+    # charter carrying the plan, verify transcripts and failure events, so the
+    # discovery lane turns the daemon's own failures into evidenced findings.
+    # Never for audit items (no recursion); capped per rolling day.
+    postmortems: bool = True
+    postmortems_per_day: int = 3
+    # Scheduled area audits: charters versioned in the target repo under
+    # ``audit_dir`` (front-matter `every: 7d`), opened as audit issues when
+    # due. Off by default — a repo opts in by carrying charters AND the
+    # operator flipping this on.
+    audits: bool = False
+    audit_dir: Path = Path(".github/sbxloop/audits")
+    # After a run delivers a PR, open a review audit of that PR — the loop
+    # evaluating the code it just wrote (defects, missing edge cases, scope
+    # drift) and filing findings for a human to promote.
+    review_deliveries: bool = True
+    reviews_per_day: int = 5
+    # Where findings ABOUT THE TOOL (sbxloop's planner, prompts, lint,
+    # delivery) go — the tool's own tracker, never the project's. Unset:
+    # such findings are only noted in the closing comment.
+    tool_repo: str | None = None
     close_on_success: bool = True
     tracking_issue: bool = True
     max_runs_per_day: int = 12
@@ -394,6 +418,7 @@ class DaemonConfig(_ConfigModel):
             self.failed_label,
             self.backlog_label,
             self.delivered_label,
+            self.audit_label,
         ]
         if any(not label.strip() for label in labels):
             raise ValueError("daemon labels must be non-empty")
@@ -406,9 +431,13 @@ class DaemonConfig(_ConfigModel):
             "max_attempts_per_item",
             "max_consecutive_failures",
             "backlog_max_per_run",
+            "postmortems_per_day",
+            "reviews_per_day",
         ):
             if getattr(self, name) < 1:
                 raise ValueError(f"daemon.{name} must be >= 1")
+        if self.tool_repo is not None and not re.fullmatch(r"[\w.-]+/[\w.-]+", self.tool_repo):
+            raise ValueError(f"daemon.tool_repo must be owner/name, got {self.tool_repo!r}")
         return self
 
 

sbxloop-0.7.4/src/sbxloop/daemon/audits.py

@@ -0,0 +1,150 @@
+"""Scheduled area audits: charters versioned in the target repository.
+
+The discovery lane needs a steady supply of *good* charters, and Brett
+wants every moving part visible on GitHub. So the charters live in the
+repo itself — ``.github/sbxloop/audits/<name>.md`` with a small front-matter block —
+where they are reviewed like code, and the daemon opens each one as a
+``sbxloop:audit`` issue when it is due. What is due is decided from the
+issues that already exist (title search on GitHub, plus the store as a
+cache), so a wiped state dir cannot double-file and an audit that is still
+open is never re-opened on top of itself.
+
+Pure parsing/scheduling here; the loop does the filing.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+AUDIT_DIR = Path(".github") / "sbxloop" / "audits"
+AUDIT_TITLE_PREFIX = "audit: "
+_FRONT_MATTER = re.compile(r"\A---\s*\n(.*?)\n---\s*\n?", re.S)
+# Preferred metadata form: an HTML comment. Invisible on GitHub and left
+# alone by every Markdown formatter (mdformat rewrote a `---` YAML block
+# into a thematic break + an H2 the first time the charters shipped, and
+# the daemon then saw no metadata at all).
+_COMMENT_META = re.compile(r"\A\s*<!--\s*sbxloop(?:-audit)?\s*:?\s*(.*?)\s*-->\s*\n?", re.S)
+_EVERY = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*([dhm])\s*$", re.I)
+_UNIT_S = {"d": 86_400.0, "h": 3_600.0, "m": 60.0}
+_NAME_OK = re.compile(r"^[a-z0-9][a-z0-9._-]{0,63}$")
+
+
+@dataclass(frozen=True)
+class Charter:
+    name: str
+    every_s: float
+    enabled: bool
+    body: str
+    rel: str  # path relative to the checkout, for the issue's provenance line
+
+    @property
+    def title(self) -> str:
+        return f"{AUDIT_TITLE_PREFIX}{self.name}"
+
+
+def parse_every(text: str) -> float:
+    """``7d`` / ``12h`` / ``30m`` → seconds. ``0d`` means every tick (tests,
+    or "run once now")."""
+    m = _EVERY.match(text)
+    if not m:
+        raise ValueError(f"unrecognised interval {text!r} (use e.g. 7d, 12h, 30m)")
+    return float(m.group(1)) * _UNIT_S[m.group(2).lower()]
+
+
+def parse_charter(path: Path, rel: str | None = None) -> Charter:
+    """One charter file. Metadata keys: ``every`` (required), ``enabled``
+    (default true), given as ``<!-- sbxloop: every=7d -->`` on the first line
+    (preferred) or a ``---`` front-matter block. The name is the file stem,
+    which also keys the schedule and the issue title — keep it stable."""
+    name = path.stem
+    if not _NAME_OK.match(name):
+        raise ValueError(f"charter file name {name!r} must be lowercase [a-z0-9._-]")
+    text = path.read_text(encoding="utf-8")
+    meta: dict[str, str] = {}
+    m = _COMMENT_META.match(text)
+    if m:
+        # `<!-- sbxloop: every=7d enabled=false -->` (also `key: value`)
+        for token in re.split(r"[\s,;]+", m.group(1).strip()):
+            if not token:
+                continue
+            key, sep, value = token.partition("=") if "=" in token else token.partition(":")
+            if sep:
+                meta[key.strip().lower()] = value.strip().strip("'\"")
+    else:
+        m = _FRONT_MATTER.match(text)
+        if not m:
+            raise ValueError(
+                f"{path}: missing metadata — start the file with "
+                "`<!-- sbxloop: every=7d -->` (or a --- every: 7d --- front-matter block)"
+            )
+        for line in m.group(1).splitlines():
+            if ":" in line:
+                key, _, value = line.partition(":")
+                meta[key.strip().lower()] = value.strip().strip("'\"")
+    if "every" not in meta:
+        raise ValueError(f"{path}: front-matter needs `every: <interval>`")
+    body = text[m.end() :].strip()
+    if not body:
+        raise ValueError(f"{path}: charter body is empty")
+    enabled = meta.get("enabled", "true").lower() not in ("false", "no", "0", "off")
+    return Charter(
+        name=name,
+        every_s=parse_every(meta["every"]),
+        enabled=enabled,
+        body=body,
+        rel=rel or path.name,
+    )
+
+
+def load_charters(checkout: Path, audit_dir: Path = AUDIT_DIR) -> tuple[list[Charter], list[str]]:
+    """(charters, problems) under ``checkout/audit_dir``; a bad file is a
+    problem string, never a crash — one broken charter must not stop the
+    others."""
+    folder = checkout / audit_dir
+    if not folder.is_dir():
+        return [], []
+    charters: list[Charter] = []
+    problems: list[str] = []
+    for path in sorted(folder.glob("*.md")):
+        try:
+            charters.append(parse_charter(path, path.relative_to(checkout).as_posix()))
+        except (ValueError, OSError) as exc:
+            problems.append(str(exc))
+    return charters, problems
+
+
+def due_charters(
+    charters: list[Charter], last_filed: dict[str, float], now: float
+) -> list[Charter]:
+    """Enabled charters whose interval has elapsed since they were last
+    filed (never filed → due)."""
+    out = []
+    for c in charters:
+        if not c.enabled:
+            continue
+        last = last_filed.get(c.name)
+        if last is None or now - last >= c.every_s:
+            out.append(c)
+    return out
+
+
+def issue_body(charter: Charter, marker: str) -> str:
+    return (
+        f"{charter.body}\n\n---\n"
+        f"Scheduled audit `{charter.name}` (every {describe_every(charter.every_s)}); "
+        f"charter: `{charter.rel}`.\n"
+        f"{marker}"
+    )
+
+
+def audit_marker(name: str) -> str:
+    return f"<!-- sbxloop-audit {name} -->"
+
+
+def describe_every(seconds: float) -> str:
+    for unit, size in (("d", 86_400.0), ("h", 3_600.0), ("m", 60.0)):
+        if seconds >= size and seconds % size == 0:
+            return f"{int(seconds // size)}{unit}"
+    return f"{seconds:g}s"

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/daemon/backlog.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import hashlib
 import logging
 from pathlib import Path
+from typing import NamedTuple
 
 from sbxloop.daemon.sources import WorkSource, parse_markdown_item
 from sbxloop.daemon.store import DaemonStore
@@ -29,6 +30,84 @@ logger = logging.getLogger(__name__)
 
 BACKLOG_SUBDIR = Path(".sbxloop") / "backlog"
 
+# The audit lane's contract (discovery on GitHub): the deliverable is issues.
+AUDIT_INSTRUCTIONS = (
+    "This is an AUDIT: your deliverable is a set of well-evidenced findings, not "
+    "code. Do not modify the tree except to write findings under "
+    "`.sbxloop/backlog/` in the workspace — one markdown file per finding, first "
+    "line `# <short, specific title>`, then these sections: **Evidence** (file:line "
+    "references and quoted lines that show the problem), **Repro / how to observe** "
+    "(a command, a test, or the exact scenario), **Proposal** (a one-line remedy), "
+    "**Size** (small | medium | large), **Kind** (bug | test | docs | refactor). "
+    "No finding without evidence. At most 5 findings — pick the ones that matter. "
+    "If the charter turns up nothing real, write no files and say so in your "
+    "summary: an empty result is a valid, honest outcome. Each file becomes a "
+    "GitHub issue for a human to triage. ROUTING: findings about THIS PROJECT's "
+    "code go directly under `.sbxloop/backlog/`. Findings about sbxloop itself — "
+    "the tool that ran you: its planner, prompts, verify lint, delivery, daemon — "
+    "go under `.sbxloop/backlog/tool/` instead; they are filed to the tool's own "
+    "tracker when the operator configured one, otherwise only noted in the closing "
+    "comment, never filed as issues of this project."
+)
+
+TOOL_SUBDIR = BACKLOG_SUBDIR / "tool"
+
+
+class ToolFindings(NamedTuple):
+    filed: list[str]  # refs filed upstream (tool_repo configured)
+    unfiled: list[str]  # titles noted only (no tool_repo)
+
+
+def collect_tool_findings(
+    run: RunRecord,
+    *,
+    dstore: DaemonStore,
+    source: WorkSource,
+    max_items: int,
+    now: float,
+) -> ToolFindings:
+    """Findings the run addressed to the TOOL (``.sbxloop/backlog/tool/``):
+    filed to the tool's tracker via ``source.file_tool_backlog`` when the
+    operator configured ``[daemon] tool_repo``, otherwise returned as
+    titles for the closing comment — never as issues of the project."""
+    if not run.mounted or run.workspace is None:
+        return ToolFindings([], [])
+    folder = run.workspace / TOOL_SUBDIR
+    if not folder.is_dir():
+        return ToolFindings([], [])
+    filer = getattr(source, "file_tool_backlog", None)
+    filed: list[str] = []
+    unfiled: list[str] = []
+    for path in sorted(folder.glob("*.md")):
+        try:
+            title, body = parse_markdown_item(path.read_text(), path.stem)
+        except OSError:
+            continue
+        if filer is None:
+            unfiled.append(title)
+            continue
+        fp = fingerprint("tool:" + title, body)
+        if dstore.backlog_seen(fp):
+            continue
+        if len(filed) >= max_items:
+            unfiled.append(title)
+            continue
+        try:
+            ref = filer(title, body, run.run_id)
+        except Exception:
+            logger.warning(
+                "tool finding %r from run %s could not be filed", title, run.run_id, exc_info=True
+            )
+            unfiled.append(title)
+            continue
+        if ref is None:
+            unfiled.append(title)
+            continue
+        dstore.backlog_record(fp, run.run_id, ref, now)
+        filed.append(ref)
+    return ToolFindings(filed, unfiled)
+
+
 BACKLOG_INSTRUCTIONS = (
     "If you identify follow-up work that is OUT OF SCOPE for this outcome, do "
     "not expand scope. Write each such item as its own markdown file under "

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/daemon/discord_format.py

@@ -891,7 +891,8 @@ def format_for_discord(
 def _origin(item: WorkItem) -> tuple[str, str]:
     """(label, kind) for where a work item came from."""
     if item.source == "github":
-        return f"issue #{item.source_key}", "github"
+        prefix = "audit" if item.kind == "audit" else "issue"
+        return f"{prefix} #{item.source_key}", "github"
     return f"inbox {code(item.source_key)}", "inbox"
 
 
@@ -1037,6 +1038,8 @@ def items_lines(items: list[WorkItem], limit: int = 20) -> str:
     rows = []
     for i in items[:limit]:
         row = f"{ITEM_STATE_MARKER.get(i.state, '•')} {code(i.item_id)} {i.state} · "
+        if i.kind == "audit":
+            row += "🔎 audit · "
         row += link(_one_line(i.title, 60), i.url) if i.url else _one_line(i.title, 60)
         row += f" · attempts {i.attempts}"
         if i.run_id:

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/daemon/loop.py

@@ -26,8 +26,16 @@ from typing import Any, NamedTuple, Protocol
 
 from sbxloop import hostgit
 from sbxloop.config import Config, GithubConfig, SandboxConfig
-from sbxloop.daemon.backlog import BACKLOG_INSTRUCTIONS, collect_backlog
+from sbxloop.daemon.audits import audit_marker, due_charters, issue_body, load_charters
+from sbxloop.daemon.backlog import (
+    AUDIT_INSTRUCTIONS,
+    BACKLOG_INSTRUCTIONS,
+    ToolFindings,
+    collect_backlog,
+    collect_tool_findings,
+)
 from sbxloop.daemon.model import RunReport, TickOutcome, TickResult, WorkItem
+from sbxloop.daemon.postmortem import build_dossier
 from sbxloop.daemon.sources import WorkSource
 from sbxloop.daemon.store import DaemonStore
 from sbxloop.engine.engine import LoopEngine
@@ -49,6 +57,9 @@ from sbxloop.sbx.prune import remove_run_sandbox, remove_run_sandbox_secrets
 
 logger = logging.getLogger(__name__)
 
+# How often the audit scheduler fast-forwards the checkout to see new charters.
+AUDIT_REFRESH_S = 600.0
+
 
 class Frontend(Protocol):
     """What a human-facing channel (Discord) sees of the loop's lifecycle.
@@ -118,6 +129,8 @@ class DaemonLoop:
         self._runner = runner or self._default_runner
         self._stop = threading.Event()
         self._paused = False
+        self._audit_problems_seen: set[str] = set()
+        self._last_audit_refresh = float("-inf")
         self._current: RunHandle | None = None
         self._current_lock = threading.Lock()
         self._cancel_request: CancelRequest | None = None
@@ -346,6 +359,7 @@ class DaemonLoop:
                     f"daily run cap reached ({started_today}/{cap}); idling until the window rolls"
                 )
             return TickResult(idle_kind="daily_cap")
+        self._schedule_audits(now)
         discovered = self._discover(now)
         item = self.dstore.next_queued(now, self.config.daemon.retry_backoff_s)
         if item is None:
@@ -638,7 +652,11 @@ class DaemonLoop:
         now = self.clock()
         report = self._report(run_id, result)
         if result is not None and report.succeeded:
-            self._collect_backlog(run_id, source)
+            filed = self._collect_backlog(run_id, source)
+            tool = self._collect_tool_findings(run_id, source)
+            report = report._replace(
+                filed=tuple(filed), tool_filed=tuple(tool.filed), tool_noted=tuple(tool.unfiled)
+            )
             self.dstore.mark_done(item.item_id, now)
             self.dstore.finish_ledger(run_id, "done", now)
             self._set_breaker(None, 0)
@@ -647,7 +665,9 @@ class DaemonLoop:
             self._notify(
                 f"✅ {item.item_id} done ({report.task_summary})"
                 + (f" · PR {report.delivery[1]}" if report.delivery else "")
+                + (f" · filed {len(report.filed)} finding(s)" if item.kind == "audit" else "")
             )
+            self._file_review(item, run_id, report)
             return "done"
         if result is not None and result.state == "completed" and report.delivery_error:
             # Work done, PR failed: a human must look; retrying would redo the work.
@@ -659,6 +679,7 @@ class DaemonLoop:
             source.report_delivery_failed(item, report)
             self._frontend_finished(item, report)
             self._notify(f"⚠ {item.item_id} completed but delivery failed: {report.delivery_error}")
+            self._file_postmortem(item, run_id, f"delivery failed: {report.delivery_error}")
             return "delivery_failed"
         reason = str(error) if error is not None else f"run ended {report.state}"
         attempts_left = self.config.daemon.max_attempts_per_item - item.attempts
@@ -673,6 +694,7 @@ class DaemonLoop:
             self.dstore.mark_failed(item.item_id, reason, now, requeue=False)
             source.report_abandoned(item, reason)
             self._notify(f"❌ {item.item_id} abandoned after {item.attempts} attempt(s): {reason}")
+            self._file_postmortem(item, run_id, f"abandoned: {reason}")
             outcome = "abandoned"
         self._frontend_finished(item, report)
         if self._consecutive_failures >= self.config.daemon.max_consecutive_failures:
@@ -738,7 +760,10 @@ class DaemonLoop:
                     # issue already is one (#251); the summary comment there
                     # carries the same information.
                     "report": self.config.daemon.tracking_issue,
-                    "deliver": True,
+                    # An audit's output is the issues it files; delivering
+                    # its (deliberately unchanged) tree would only raise
+                    # "nothing to deliver" and mis-settle it as failed.
+                    "deliver": item.kind != "audit",
                     "deliver_draft": self.config.daemon.deliver_draft,
                     "create_repo": False,
                 }
@@ -807,7 +832,9 @@ class DaemonLoop:
         else:
             origin = f"inbox file `{item.source_key}`"
         parts.append(f"---\nThis work item came from: {origin}.")
-        if self.config.daemon.backlog != "off":
+        if item.kind == "audit":
+            parts.append(AUDIT_INSTRUCTIONS)
+        elif self.config.daemon.backlog != "off":
             parts.append(BACKLOG_INSTRUCTIONS)
         return "\n\n".join(parts)
 
@@ -853,14 +880,136 @@ class DaemonLoop:
         workspace = str(result.workspace) if result is not None and result.workspace else None
         return RunReport(run_id, state, summary, tracking, delivery, delivery_error, workspace)
 
-    def _collect_backlog(self, run_id: str, source: WorkSource) -> None:
+    def _schedule_audits(self, now: float) -> None:
+        """Open due charters from the checkout's ``audit_dir`` as audit issues.
+
+        Runs after the pause/breaker/cap gates (a stressed daemon does not
+        add work for itself) and before discovery, so a freshly filed audit
+        is picked up in the same tick. GitHub is the schedule's source of
+        truth (a still-open audit is never re-filed; one created within the
+        interval counts as filed) with the store as a cache; a GitHub
+        hiccup skips this tick, never raises."""
+        daemon = self.config.daemon
+        if not daemon.audits:
+            return
+        github: Any = next((s for s in self.sources if s.name == "github"), None)
+        if github is None or not hasattr(github, "file_audit"):
+            return
+        checkout = self._workspace_checkout()
+        if checkout is None:
+            return
+        # The checkout is normally refreshed only when a run starts, so
+        # charters merged after the last run would never be seen (field:
+        # the first deploy read a clone that predated its own charters).
+        # Refresh here too, throttled — a fetch a minute is not the point.
+        if now - self._last_audit_refresh >= AUDIT_REFRESH_S:
+            self._last_audit_refresh = now
+            self._refresh_workspace()
+        charters, problems = load_charters(checkout, daemon.audit_dir)
+        for problem in problems:
+            if problem not in self._audit_problems_seen:
+                self._audit_problems_seen.add(problem)
+                self._notify(f"⚠ audit charter skipped: {problem}")
+        for charter in due_charters(charters, self.dstore.audit_last_filed(), now):
+            try:
+                since = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now - charter.every_s))
+                is_open, filed_recently = github.audit_issue_state(charter.title, since)
+                if is_open or filed_recently:
+                    # Someone (or a previous process) already filed it: sync
+                    # the cache so we stop asking GitHub every tick.
+                    self.dstore.record_audit(charter.name, "gh:existing", now)
+                    continue
+                ref = github.file_audit(
+                    charter.title, issue_body(charter, audit_marker(charter.name))
+                )
+                self.dstore.record_audit(charter.name, ref, now)
+                self._notify(f"🔎 scheduled audit filed: {charter.title} → {ref}")
+            except Exception:
+                logger.warning("scheduled audit %s could not be filed", charter.name, exc_info=True)
+
+    def _collect_tool_findings(self, run_id: str, source: WorkSource) -> ToolFindings:
+        """Findings addressed to the tool: filed upstream when tool_repo is
+        set, otherwise noted for the closing comment. Never the project's."""
+        if self.config.daemon.backlog == "off":
+            return ToolFindings([], [])
+        target = next((s for s in self.sources if s.name == self.config.daemon.backlog), None)
+        if target is None:
+            return ToolFindings([], [])
+        try:
+            return collect_tool_findings(
+                self.store.get_run(run_id),
+                dstore=self.dstore,
+                source=target,
+                max_items=self.config.daemon.backlog_max_per_run,
+                now=self.clock(),
+            )
+        except SbxloopError:
+            logger.warning("tool-finding collection failed for %s", run_id, exc_info=True)
+            return ToolFindings([], [])
+
+    def _file_review(self, item: WorkItem, run_id: str, report: RunReport) -> None:
+        """The loop evaluating the code it just wrote: after a patch item
+        delivers a PR, open a review audit of that PR. Once per run, patch
+        items only (an audit has no PR), capped per rolling day, best-effort."""
+        daemon = self.config.daemon
+        if not daemon.review_deliveries or item.kind != "patch" or report.delivery is None:
+            return
+        github: Any = next((s for s in self.sources if s.name == "github"), None)
+        if github is None or not hasattr(github, "file_review"):
+            return
+        now = self.clock()
+        try:
+            if self.dstore.review_filed(run_id):
+                return
+            if self.dstore.reviews_since(now - DAY_S) >= daemon.reviews_per_day:
+                logger.info("delivery review for %s skipped: daily cap reached", run_id)
+                return
+            number, url = report.delivery
+            ref = github.file_review(item, number, url, run_id)
+            self.dstore.record_review(run_id, number, ref, now)
+            self._notify(f"🔎 review audit filed for PR #{number}: {ref}")
+        except Exception:
+            logger.warning("delivery review for %s could not be filed", run_id, exc_info=True)
+
+    def _file_postmortem(self, item: WorkItem, run_id: str, reason: str) -> None:
+        """Turn the daemon's own failure into a discovery-lane charter.
+
+        Only for patch items — a failed audit filing a post-mortem that is
+        itself an audit would recurse — only once per run, and capped per
+        rolling day so a bad night cannot flood the tracker. Best-effort:
+        the item is already settled; this must never change that."""
+        daemon = self.config.daemon
+        if not daemon.postmortems or item.kind != "patch":
+            return
+        github: Any = next((s for s in self.sources if s.name == "github"), None)
+        if github is None or not hasattr(github, "file_postmortem"):
+            return
+        now = self.clock()
+        try:
+            if self.dstore.postmortem_filed(run_id):
+                return
+            if self.dstore.postmortems_since(now - DAY_S) >= daemon.postmortems_per_day:
+                logger.info("post-mortem for %s skipped: daily cap reached", run_id)
+                return
+            run_ids = self.dstore.runs_for_item(item.item_id) or [run_id]
+            dossier = build_dossier(
+                self.store, item, run_ids, reason, state_dir=str(self.config.state_dir)
+            )
+            ref = github.file_postmortem(item, dossier, run_id)
+            self.dstore.record_postmortem(run_id, item.item_id, ref, now)
+            self._notify(f"🔎 post-mortem filed for {item.item_id}: {ref}")
+        except Exception:
+            logger.warning("post-mortem for %s could not be filed", run_id, exc_info=True)
+
+    def _collect_backlog(self, run_id: str, source: WorkSource) -> list[str]:
+        """File the run's backlog items; returns their refs (``gh:<n>``)."""
         mode = self.config.daemon.backlog
         if mode == "off":
-            return
+            return []
         target = next((s for s in self.sources if s.name == mode), None)
         if target is None:
             logger.warning("backlog mode %r but no such source is active", mode)
-            return
+            return []
         try:
             record = self.store.get_run(run_id)
             filed = collect_backlog(
@@ -873,9 +1022,10 @@ class DaemonLoop:
             )
         except SbxloopError:
             logger.warning("backlog collection failed for %s", run_id, exc_info=True)
-            return
+            return []
         if filed:
             self._notify(f"filed {len(filed)} backlog item(s) from {run_id}: {', '.join(filed)}")
+        return list(filed)
 
     # -- recovery ------------------------------------------------------------------------
 

{sbxloop-0.7.2 → sbxloop-0.7.4}/src/sbxloop/daemon/model.py

@@ -9,6 +9,10 @@ from pydantic import BaseModel, ConfigDict
 from sbxloop.engine.model import RunState
 
 ItemSource = Literal["github", "inbox"]
+# What a run of the item is FOR. ``patch``: change the tree, deliver a PR.
+# ``audit``: investigate and file findings as backlog issues — no delivery,
+# the tree is disposable, the issues are the output (the discovery lane).
+ItemKind = Literal["patch", "audit"]
 # ``cancelled`` is an operator's decision (``!sbx cancel``), not a failure:
 # it is terminal for the daemon (no retry, no breaker count) while the run
 # itself stays resumable from the CLI.
@@ -32,6 +36,7 @@ class WorkItem(BaseModel):
     item_id: str
     source: ItemSource
     source_key: str
+    kind: ItemKind = "patch"
     title: str
     body: str = ""
     url: str = ""
@@ -62,6 +67,12 @@ class RunReport(NamedTuple):
     cancelled_by: str | None = None
     # ``!sbx cancel --retry``: the item went straight back to the queue.
     requeued: bool = False
+    # Backlog issues the run filed (``gh:<n>`` refs) — an audit's deliverable.
+    filed: tuple[str, ...] = ()
+    # Findings addressed to sbxloop itself: filed upstream (``[daemon]
+    # tool_repo``) as refs, or merely noted by title in the closing comment.
+    tool_filed: tuple[str, ...] = ()
+    tool_noted: tuple[str, ...] = ()
 
     @property
     def succeeded(self) -> bool: