agentkernel-cli 0.1.0__py3-none-any.whl

agentkernel/config.py

@@ -0,0 +1,224 @@
+"""Configuration (design §11).
+
+Precedence: explicit constructor args > environment (``AGENTKERNEL_*``) >
+config file (``agentkernel.toml``) > defaults. API keys come **only** from the
+environment (``ANTHROPIC_API_KEY``, ``OPENAI_API_KEY``, …) and are never read
+from, or written to, the config file or traces.
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+from typing import Any
+
+ENV_PREFIX = "AGENTKERNEL_"
+DEFAULT_CONFIG_FILE = "agentkernel.toml"
+
+
+@dataclass
+class Config:
+    provider: str = "anthropic"  # "anthropic" | "openai" | "local"
+    model: str = "claude-sonnet-4-6"
+    base_url: str | None = None  # for local/OpenAI-compatible endpoints
+    max_output_tokens: int = 4096
+    output_reserve: int = 8192  # budget headroom for the reply
+    max_iterations: int = 25
+    keep_recent_turns: int = 6
+    max_tool_result_tokens: int = 4096
+    tool_concurrency: int = 4  # max parallel tool-call executions per turn (1 = sequential)
+    stream: bool = True  # stream model text to the terminal as it arrives
+    approval_policy: str = "always_ask"  # always_ask | auto_allow | deny_mutations | smart
+    approval_judge_model: str | None = None  # model for `smart` risk judging (§18.1)
+    redact_tool_output: bool = True  # scrub secret-looking strings from tool results (§18.1)
+    checkpoints: bool = False  # back up files before edits; expose a `rollback` tool (§18.1)
+    enable_todo: bool = False  # register the in-session `todo` planning tool (§18.4)
+    enable_clarify: bool = False  # register the `clarify` ask-the-user tool (§18.4)
+    enable_plugins: bool = False  # auto-load tools from plugins_dir (§18.7)
+    plugins_dir: str = "plugins"  # directory of plugin tool modules
+    cron_path: str = ".agentkernel/cron.json"  # scheduled-job store (§18.2)
+    enable_kanban: bool = False  # register the `kanban` work-board tool (§18.3)
+    kanban_path: str = ".agentkernel/kanban.json"  # shared work-board store
+    approval_allowlist: list[str] = field(default_factory=list)  # patterns that skip the gate
+    plan_mode: bool = False              # batch-approve the whole tool plan at once
+    sandbox: str = "local"  # "local" | "docker" (design §10.3)
+    sandbox_image: str = "python:3.12-slim"  # image for the docker sandbox
+    sandbox_network: str = "none"  # docker container network ("none" | "bridge" | …)
+    working_dir: str = "."
+    summarizer_model: str | None = None  # cheap model for compaction; None -> structural
+    log_dir: str = ".agentkernel/traces"
+    mcp_log_dir: str = ".agentkernel/mcp-logs"  # per-server stderr logs
+    max_cost_usd: float | None = None  # stop if cumulative cost exceeds this
+    max_input_tokens_per_run: int | None = None  # stop if input tokens exceed this
+    profile: str | None = None  # active profile name (Phase 5)
+    profile_dir: str = "profiles"
+    memory_store: str | None = None  # "file" | "sqlite" | "memory" | None (Phase 3)
+    memory_dir: str | None = None
+    enable_memory_tools: bool = False  # register remember/recall/forget tools (Phase 3)
+    memory_notes_path: str = ".agentkernel/memory/notes.jsonl"  # the notebook file
+    memory_auto_context: bool = False  # auto-inject recalled notes into user message
+    memory_auto_context_limit: int = 3  # max notes per auto-recall
+    memory_store_budget: int | None = None  # max tokens to persist per session
+    memory_curator_model: str | None = None  # cheap model for memory extract/consolidate
+    semantic_search: bool = False  # rank note recall with dense embeddings
+    embedding_model: str = "text-embedding-3-small"
+    embedding_dimensions: int | None = None  # optional truncation (OpenAI only)
+    embedding_base_url: str | None = None  # OpenAI-compatible endpoint
+    embedding_api_key_env: str = "OPENAI_API_KEY"  # env var holding API key
+    skills_dir: str = "skills"  # Phase 4
+    skills: list[str] = field(default_factory=list)  # active skill names (Phase 4)
+    enable_graph: bool = False  # register graph_add/graph_query tools (Phase 6)
+    graph_path: str = ".agentkernel/graph.jsonl"  # Phase 6
+    improvements_dir: str = ".agentkernel/improvements"  # Phase 7
+    enable_spawn: bool = False  # register the sub-agent `spawn` tool (design §13)
+    spawn_max_depth: int = 2  # recursion limit for nested spawn
+    judge_model: str | None = None  # model used to score evals; None -> `model`
+    eval_threshold: float = 0.6  # pass/fail score cutoff for evals
+    eval_rubric: str | None = None  # default rubric for eval runs
+    semantic_search_lsh_bits: int | None = None  # LSH index bits for large notebooks
+
+    @classmethod
+    def load(
+        cls,
+        config_file: str | os.PathLike[str] = DEFAULT_CONFIG_FILE,
+        *,
+        env: dict[str, str] | None = None,
+        **overrides: Any,
+    ) -> Config:
+        """Build a Config from defaults < file < environment < explicit overrides."""
+        env = os.environ if env is None else env
+        values: dict[str, Any] = {}
+
+        path = Path(config_file)
+        if path.is_file():
+            with path.open("rb") as fh:
+                file_data = tomllib.load(fh)
+            values.update({k: v for k, v in file_data.items() if k in _FIELD_TYPES})
+
+        for name, typ in _FIELD_TYPES.items():
+            raw = env.get(ENV_PREFIX + name.upper())
+            if raw is not None:
+                values[name] = _coerce(raw, typ)
+
+        values.update({k: v for k, v in overrides.items() if k in _FIELD_TYPES})
+        return cls(**values)
+
+
+_FIELD_TYPES: dict[str, Any] = {f.name: f.type for f in fields(Config)}
+
+# State that is the agent's user-global "brain & library" vs per-project.
+# Defaults anchor to the appropriate root (see paths.py); a value customized in
+# project config anchors to the project instead, so per-project overrides win.
+_GLOBAL_PATH_FIELDS = (
+    "memory_notes_path", "graph_path", "skills_dir", "profile_dir",
+    "improvements_dir", "cron_path",
+)
+_PROJECT_PATH_FIELDS = (
+    "log_dir", "mcp_log_dir", "kanban_path", "plugins_dir", "memory_dir",
+)
+
+
+def _read_config_fields(path: Path) -> dict[str, Any]:
+    """Read recognized fields from a TOML config file."""
+    with path.open("rb") as fh:
+        data = tomllib.load(fh)
+    return {k: v for k, v in data.items() if k in _FIELD_TYPES}
+
+
+def resolve_config(
+    config_arg: str | os.PathLike[str] | None = None,
+    *,
+    cwd: str | os.PathLike[str] = ".",
+    env: dict[str, str] | None = None,
+    **overrides: Any,
+) -> tuple[Config, Path | None]:
+    """Resolve config for running anywhere (global brain, project sessions).
+
+    Precedence: explicit ``config_arg`` (single file) **or** layered
+    ``<home>/config.toml`` < ``<project>/agentkernel.toml``, then env, then
+    ``overrides``. State paths are anchored to the agent home (global fields) or
+    the project root (project fields); ``working_dir`` defaults to the project
+    root. Returns ``(config, project_config_path)``.
+    """
+    from agentkernel.paths import (
+        agent_home,
+        anchor_path,
+        find_project_config,
+        find_project_root,
+        global_config_path,
+    )
+
+    env = os.environ if env is None else env
+    home = agent_home(env)
+    project_root = find_project_root(cwd)
+    values: dict[str, Any] = {}
+    project_config_path: Path | None = None
+
+    if config_arg is not None:
+        explicit = Path(config_arg)
+        if explicit.is_file():
+            values.update(_read_config_fields(explicit))
+            project_config_path = explicit
+    else:
+        gpath = global_config_path(home)
+        if gpath.is_file():
+            values.update(_read_config_fields(gpath))
+        ppath = find_project_config(project_root)
+        if ppath is not None:
+            values.update(_read_config_fields(ppath))
+            project_config_path = ppath
+
+    for name, typ in _FIELD_TYPES.items():
+        raw = env.get(ENV_PREFIX + name.upper())
+        if raw is not None:
+            values[name] = _coerce(raw, typ)
+    values.update({k: v for k, v in overrides.items() if k in _FIELD_TYPES})
+
+    config = Config(**values)
+    defaults = Config()
+
+    if config.working_dir in (".", "", None):
+        config.working_dir = str(project_root)
+    else:
+        config.working_dir = anchor_path(config.working_dir, base=project_root)
+
+    for name in _GLOBAL_PATH_FIELDS:
+        value = getattr(config, name)
+        if value is None:
+            continue
+        base = home if value == getattr(defaults, name) else project_root
+        setattr(config, name, anchor_path(value, base=base))
+
+    for name in _PROJECT_PATH_FIELDS:
+        value = getattr(config, name)
+        if value is None:
+            if name == "memory_dir":
+                config.memory_dir = anchor_path(".agentkernel/memory", base=project_root)
+            continue
+        setattr(config, name, anchor_path(value, base=project_root))
+
+    return config, project_config_path
+
+
+def _coerce(raw: str, typ: Any) -> Any:
+    """Coerce an environment string to the field's declared type."""
+    # Field types are stringified annotations under ``from __future__ import``.
+    if typ == "bool":
+        return raw.strip().lower() in ("1", "true", "yes", "on")
+    if typ == "int":
+        return int(raw)
+    if typ == "float":
+        return float(raw)
+    if typ == "list[str]":
+        return [s.strip() for s in raw.split(",") if s.strip()]
+    if typ in ("str | None", "int | None", "float | None"):
+        if raw == "":
+            return None
+        if "int" in typ:
+            return int(raw)
+        if "float" in typ:
+            return float(raw)
+        return raw
+    return raw

agentkernel/context/__init__.py

@@ -0,0 +1,17 @@
+"""Context management: accounting and compaction (design §9)."""
+
+from agentkernel.context.manager import (
+    CompactionEvent,
+    ContextManager,
+    ModelSummarizer,
+    estimate_tokens,
+    structural_summary,
+)
+
+__all__ = [
+    "ContextManager",
+    "CompactionEvent",
+    "ModelSummarizer",
+    "estimate_tokens",
+    "structural_summary",
+]

agentkernel/context/manager.py

@@ -0,0 +1,216 @@
+"""Conversation context: accounting, budget, and compaction (design §9).
+
+The system prompt and tool definitions are NOT in this message list — they live
+in the cacheable prefix (§9.3) and are passed to the provider separately. So
+compaction here operates only on user/assistant/tool messages and can never
+drop the system prompt.
+
+Compaction collapses the oldest completed turns into one synthetic assistant
+summary, always keeping the most recent ``keep_recent_turns`` turns verbatim and
+never splitting an assistant tool-call from its tool results (§9.2).
+"""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from agentkernel.context.truncate import CHARS_PER_TOKEN, truncate_text
+from agentkernel.types import Message
+
+if TYPE_CHECKING:
+    from agentkernel.providers import Provider
+
+# A summarizer turns a list of (old) messages into one summary string. The
+# default is the deterministic structural fallback below; a model-based
+# summarizer can be injected here (design §9.2).
+Summarizer = Callable[[list[Message]], str]
+
+
+@dataclass
+class CompactionEvent:
+    """Telemetry for one compaction pass (design §9.2)."""
+
+    turns_collapsed: int
+    tokens_before: int
+    tokens_after: int
+
+
+def estimate_tokens(message: Message) -> int:
+    """Conservative chars/4 estimate for one message (design §9.1)."""
+    chars = len(message.content or "")
+    for tc in message.tool_calls:
+        chars += len(tc.name) + len(json.dumps(tc.arguments))
+    for r in message.tool_results:
+        chars += len(r.content or "")
+    return max(1, chars // CHARS_PER_TOKEN)
+
+
+def structural_summary(messages: list[Message]) -> str:
+    """Deterministic, offline summary: message counts, tools used, files touched."""
+    users = sum(1 for m in messages if m.role == "user")
+    assistants = sum(1 for m in messages if m.role == "assistant")
+    tool_names: list[str] = []
+    paths: set[str] = set()
+    for m in messages:
+        for tc in m.tool_calls:
+            tool_names.append(tc.name)
+            p = tc.arguments.get("path")
+            if isinstance(p, str):
+                paths.add(p)
+    parts = [f"{users} user and {assistants} assistant message(s) were exchanged"]
+    if tool_names:
+        counts = Counter(tool_names)
+        parts.append("tools used: " + ", ".join(f"{n}×{c}" for n, c in counts.items()))
+    if paths:
+        parts.append("files touched: " + ", ".join(sorted(paths)))
+    return "; ".join(parts) + "."
+
+
+def _render_transcript(messages: list[Message]) -> str:
+    """A compact, readable transcript of messages for the summarizer prompt."""
+    lines: list[str] = []
+    for m in messages:
+        if m.content and m.role in ("user", "assistant"):
+            lines.append(f"{m.role}: {m.content}")
+        for tc in m.tool_calls:
+            lines.append(f"assistant called {tc.name}({json.dumps(tc.arguments)})")
+        for r in m.tool_results:
+            lines.append(f"tool[{'error' if r.is_error else 'ok'}]: {r.content}")
+    return "\n".join(lines)
+
+
+class ModelSummarizer:
+    """Summarize old turns with a (cheap) model call (design §9.2).
+
+    Wired when ``config.summarizer_model`` is set. Summarization is best-effort:
+    any provider failure falls back to the deterministic ``structural_summary``
+    so compaction — and therefore the loop — can never crash on it.
+    """
+
+    def __init__(self, provider: Provider, *, max_tokens: int = 512) -> None:
+        self._provider = provider
+        self._max_tokens = max_tokens
+
+    def __call__(self, messages: list[Message]) -> str:
+        # Bound the transcript so it fits the summarizer's own context.
+        transcript = truncate_text(_render_transcript(messages), 4000)
+        prompt = Message(
+            role="user",
+            content=(
+                "Summarize the earlier conversation below so it can be dropped from "
+                "context without losing continuity. Be concise; preserve key facts, "
+                "decisions, tool results, and file paths.\n\n" + transcript
+            ),
+        )
+        try:
+            resp = self._provider.complete(
+                [prompt],
+                [],
+                max_tokens=self._max_tokens,
+                temperature=0.0,
+                system="You are a precise note-taker producing a context summary.",
+            )
+        except Exception:  # noqa: BLE001 - best-effort; never break the loop
+            return structural_summary(messages)
+        return resp.message.content.strip() or structural_summary(messages)
+
+
+class ContextManager:
+    def __init__(
+        self,
+        *,
+        budget: int | None = None,
+        keep_recent_turns: int = 6,
+        summarizer: Summarizer | None = None,
+        estimator: Callable[[Message], int] = estimate_tokens,
+    ) -> None:
+        # budget=None means unlimited (no compaction) — used by tests that don't
+        # exercise context limits.
+        self._messages: list[Message] = []
+        self._budget = budget
+        self._keep_recent_turns = keep_recent_turns
+        # A model-based summarizer (ModelSummarizer, wired from
+        # config.summarizer_model) can be injected; otherwise the deterministic
+        # structural fallback is used.
+        self._summarize: Summarizer = summarizer or structural_summary
+        self._estimate = estimator
+        self._pending_compaction: CompactionEvent | None = None
+
+    def add(self, message: Message) -> None:
+        if message.token_estimate is None:
+            message.token_estimate = self._estimate(message)
+        self._messages.append(message)
+
+    def messages(self) -> list[Message]:
+        """The full stored history."""
+        return list(self._messages)
+
+    def clear(self) -> None:
+        """Drop all stored messages. System-prompt/tool prefix is unaffected."""
+        self._messages = []
+
+    def window(self) -> list[Message]:
+        """Messages to send this turn, compacted in place if over budget (§9.2)."""
+        if self._budget is not None and self._total() > self._budget:
+            self._compact()
+        return list(self._messages)
+
+    def take_compaction(self) -> CompactionEvent | None:
+        """Return and clear the most recent compaction event (for telemetry)."""
+        event, self._pending_compaction = self._pending_compaction, None
+        return event
+
+    # --- internals ---------------------------------------------------------
+
+    def _total(self) -> int:
+        return sum(m.token_estimate or 0 for m in self._messages)
+
+    def _group_turns(self) -> list[list[Message]]:
+        """Group messages into atomic units. An assistant tool-call message is
+        bound to the tool-result message that answers it so compaction can never
+        split an open pair (§9.2)."""
+        groups: list[list[Message]] = []
+        i = 0
+        n = len(self._messages)
+        while i < n:
+            m = self._messages[i]
+            if (
+                m.role == "assistant"
+                and m.tool_calls
+                and i + 1 < n
+                and self._messages[i + 1].role == "tool"
+            ):
+                groups.append([m, self._messages[i + 1]])
+                i += 2
+            else:
+                groups.append([m])
+                i += 1
+        return groups
+
+    def _compact(self) -> None:
+        groups = self._group_turns()
+        if len(groups) <= self._keep_recent_turns:
+            return  # nothing old enough to compact; keep recent turns verbatim
+
+        old = groups[: -self._keep_recent_turns]
+        recent = groups[-self._keep_recent_turns :]
+        old_messages = [m for g in old for m in g]
+
+        tokens_before = self._total()
+        summary = Message(
+            role="assistant",
+            content="Earlier in this session: " + self._summarize(old_messages),
+        )
+        summary.token_estimate = self._estimate(summary)
+        recent_messages = [m for g in recent for m in g]
+
+        self._messages = [summary, *recent_messages]
+        self._pending_compaction = CompactionEvent(
+            turns_collapsed=len(old),
+            tokens_before=tokens_before,
+            tokens_after=self._total(),
+        )

agentkernel/context/truncate.py

@@ -0,0 +1,35 @@
+"""Shared truncation (design §8.4 / §9).
+
+Both large tool results and context management use this single mechanism so the
+marker and policy stay consistent. M0 needs it for ``read_file``; M2's context
+manager reuses it. Truncation keeps the head and tail and replaces the middle
+with a marker, which is more useful to the model than a hard cut.
+"""
+
+from __future__ import annotations
+
+# Rough chars-per-token heuristic for budgeting; only needs to be conservative.
+CHARS_PER_TOKEN = 4
+
+
+def truncate_text(text: str, max_tokens: int, *, hint: str = "use a narrower query") -> str:
+    """Truncate ``text`` to roughly ``max_tokens``, marking the removed middle.
+
+    Returns the text unchanged if it already fits. The marker states how many
+    bytes were dropped so the model knows the result is partial.
+    """
+    max_chars = max(max_tokens * CHARS_PER_TOKEN, 0)
+    if len(text) <= max_chars or max_chars == 0:
+        return text
+
+    marker_template = "\n… [truncated {n} bytes; {hint}] …\n"
+    # Reserve room for the marker, then split the budget between head and tail.
+    marker = marker_template.format(n=0, hint=hint)
+    body_chars = max(max_chars - len(marker), 0)
+    head_chars = body_chars // 2
+    tail_chars = body_chars - head_chars
+
+    head = text[:head_chars]
+    tail = text[len(text) - tail_chars :] if tail_chars else ""
+    dropped = len(text) - len(head) - len(tail)
+    return head + marker_template.format(n=dropped, hint=hint) + tail

agentkernel/cron.py

@@ -0,0 +1,146 @@
+"""Scheduled jobs (design §18.2).
+
+A durable, dependency-light scheduler: jobs live in a JSON file and run on a
+fixed interval. There is no long-running daemon — ``agentkernel cron tick`` runs
+whatever is due once and exits, so an OS scheduler (cron, systemd timer, Windows
+Task Scheduler) can drive it. ``cron run <id>`` runs one job immediately.
+
+Schedules are interval strings (``30s``, ``15m``, ``2h``, ``1d``, ``1w``). Full
+5-field cron expressions are intentionally left for later — the interval covers
+the common "every N" case with a fraction of the surface area.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+_UNIT_SECONDS = {"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}
+_INTERVAL_RE = re.compile(r"^\s*(\d+)\s*([smhdw])\s*$")
+
+
+def parse_interval(schedule: str) -> timedelta:
+    """Parse an interval like ``30m`` / ``2h`` into a timedelta. Raises ValueError."""
+    match = _INTERVAL_RE.match(schedule or "")
+    if not match:
+        raise ValueError(
+            f"invalid schedule {schedule!r}; use forms like '30s', '15m', '2h', '1d', '1w'"
+        )
+    return timedelta(seconds=int(match.group(1)) * _UNIT_SECONDS[match.group(2)])
+
+
+@dataclass
+class CronJob:
+    id: str
+    schedule: str
+    prompt: str
+    enabled: bool = True
+    last_run: str | None = None  # ISO-8601, UTC
+    created: str = ""
+
+    def next_run(self) -> datetime | None:
+        """When this job is next due, or None if it has never run (due now)."""
+        if self.last_run is None:
+            return None
+        try:
+            return datetime.fromisoformat(self.last_run) + parse_interval(self.schedule)
+        except ValueError:
+            return None
+
+    def is_due(self, now: datetime) -> bool:
+        if not self.enabled:
+            return False
+        nxt = self.next_run()
+        return nxt is None or now >= nxt
+
+
+class JobStore:
+    """JSON-backed store of cron jobs."""
+
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path)
+
+    def _read(self) -> list[CronJob]:
+        if not self._path.is_file():
+            return []
+        try:
+            raw = json.loads(self._path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return []
+        return [CronJob(**j) for j in raw if isinstance(j, dict)]
+
+    def _write(self, jobs: list[CronJob]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.write_text(
+            json.dumps([asdict(j) for j in jobs], indent=2), encoding="utf-8"
+        )
+
+    def list(self) -> list[CronJob]:
+        return self._read()
+
+    def get(self, job_id: str) -> CronJob | None:
+        return next((j for j in self._read() if j.id == job_id), None)
+
+    def add(self, schedule: str, prompt: str, *, enabled: bool = True) -> CronJob:
+        parse_interval(schedule)  # validate up front
+        job = CronJob(
+            id=uuid.uuid4().hex[:8],
+            schedule=schedule.strip(),
+            prompt=prompt,
+            enabled=enabled,
+            created=datetime.now(UTC).isoformat(timespec="seconds"),
+        )
+        jobs = self._read()
+        jobs.append(job)
+        self._write(jobs)
+        return job
+
+    def remove(self, job_id: str) -> bool:
+        jobs = self._read()
+        kept = [j for j in jobs if j.id != job_id]
+        if len(kept) == len(jobs):
+            return False
+        self._write(kept)
+        return True
+
+    def set_enabled(self, job_id: str, enabled: bool) -> bool:
+        return self._update(job_id, lambda j: setattr(j, "enabled", enabled))
+
+    def mark_run(self, job_id: str, when: datetime | None = None) -> bool:
+        stamp = (when or datetime.now(UTC)).isoformat(timespec="seconds")
+        return self._update(job_id, lambda j: setattr(j, "last_run", stamp))
+
+    def _update(self, job_id: str, mutate) -> bool:
+        jobs = self._read()
+        found = False
+        for j in jobs:
+            if j.id == job_id:
+                mutate(j)
+                found = True
+        if found:
+            self._write(jobs)
+        return found
+
+    def due_jobs(self, now: datetime | None = None) -> list[CronJob]:
+        now = now or datetime.now(UTC)
+        return [j for j in self._read() if j.is_due(now)]
+
+
+def run_due_jobs(store: JobStore, run_fn, *, now: datetime | None = None) -> list[tuple[str, str]]:
+    """Run every due job via ``run_fn(prompt) -> str``; mark each run. Returns
+    ``(job_id, result)`` pairs. A job whose run raises is recorded as run anyway
+    (with the error as its result) so one bad job doesn't re-fire every tick."""
+    now = now or datetime.now(UTC)
+    results: list[tuple[str, str]] = []
+    for job in store.due_jobs(now):
+        try:
+            result = run_fn(job.prompt)
+        except Exception as exc:  # noqa: BLE001 - record and continue to next job
+            result = f"[error] {exc}"
+        store.mark_run(job.id, now)
+        results.append((job.id, result))
+    return results