Idle seed-list loop: curated jobs grow B's memory; manual trigger + gated scheduler

Author: dev-pd

backend/app/api/run.py

@@ -15,6 +15,7 @@
 from app.agents.agent_a import run_agent_a
 from app.agents.agent_b import run_agent_b
 from app.core.exceptions import ReplayMissError
+from app.jobs.seed_runner import SeedResult, run_seed_pass
 from app.memory.janitor import run_janitor
 from app.models import AgentRunResult
 from app.repositories.diary import DiaryRepository
@@ -75,3 +76,22 @@ async def run(req: RunRequest) -> RunResponse:
         raise HTTPException(status_code=502, detail=str(exc)) from exc
 
     return RunResponse(a=a, b=b, note=None if probe.fetch_ok else probe.fetch_note)
+
+
+class SeedRequest(BaseModel):
+    passes: int = 1
+
+
+@router.post("/seed", response_model=SeedResult)
+async def seed(req: SeedRequest) -> SeedResult:
+    """Work the curated seed jobs with learning on, then consolidate.
+
+    This is the idle behavior, run on demand. Live (real fetch + SERP + LLM), so it
+    spends tokens per job — keep `passes` small.
+    """
+    try:
+        return await run_seed_pass(passes=req.passes, replay=False)
+    except ReplayMissError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=502, detail=str(exc)) from exc

backend/app/core/config.py

@@ -28,6 +28,11 @@ class Settings(BaseSettings):
     agent_model: str = "claude-opus-4-8"
     agent_max_tokens: int = 4096
 
+    # Idle seed loop: when enabled, the scheduler cycles the curated seed jobs to grow
+    # B's memory between user jobs. Off by default — it spends tokens, so opt in.
+    seed_idle_enabled: bool = False
+    seed_idle_interval_seconds: int = 1800
+
     @property
     def mode(self) -> str:
         """Human-readable mode label exposed by the health check."""

backend/app/jobs/scheduler.py

@@ -1,19 +1,31 @@
-"""Scheduler entrypoint (stub).
+"""Scheduler entrypoint.
 
-The real monitor scheduler arrives in Phase 4. Until then this only exists so
-`python -m app.jobs.scheduler` is a valid entrypoint; Compose runs it as an idle
-stub. Run directly, it logs once and idles.
+When `SEED_IDLE_ENABLED` is set, this cycles the curated seed jobs on a timer to
+grow Agent B's memory between user jobs (no web roaming — it only works the
+hand-picked seed list). Off by default, so it idles and spends nothing until you
+opt in.
 """
 
+import asyncio
 import logging
 import time
 
+from app.core.config import settings
+from app.jobs.seed_runner import run_idle_loop
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("scheduler")
 
 
 def main() -> None:
-    logger.info("scheduler stub started; monitor tasks are wired in Phase 4. Idling.")
+    if settings.seed_idle_enabled:
+        logger.info(
+            "seed idle loop on; cycling curated jobs every %ds",
+            settings.seed_idle_interval_seconds,
+        )
+        asyncio.run(run_idle_loop(interval_seconds=settings.seed_idle_interval_seconds))
+        return
+    logger.info("scheduler idle; set SEED_IDLE_ENABLED=true to grow B's memory.")
     while True:
         time.sleep(3600)
 

backend/app/jobs/seed_jobs.py

@@ -0,0 +1,41 @@
+"""Curated seed jobs — the work B does when idle.
+
+B never roams the web (golden invariant: no autonomous page-hunting). Instead, when
+there is no user job, it cycles this small, hand-picked list of real (url, keyword)
+pairs — "given jobs", just pre-loaded by us. Working them with learning on, then
+consolidating, fills the playbook honestly without discovering new pages.
+
+The pairs are grouped by page kind on purpose: several pages of the same kind let a
+`(page_kind, rec_type, target)` pattern recur past the promotion bar in a single
+pass. Every URL here was verified to fetch (200) with the scraper's headers.
+"""
+
+from __future__ import annotations
+
+# (url, keyword) — verified fetchable, grouped by page kind for recurrence.
+SEED_JOBS: list[tuple[str, str]] = [
+    # docs
+    ("https://developer.mozilla.org/en-US/docs/Web/CSS/flex", "css flexbox"),
+    (
+        "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises",
+        "javascript promises",
+    ),
+    ("https://docs.python.org/3/library/asyncio.html", "python asyncio"),
+    ("https://www.gnu.org/software/bash/manual/bash.html", "bash manual"),
+    # articles
+    ("https://en.wikipedia.org/wiki/Espresso", "espresso"),
+    ("https://en.wikipedia.org/wiki/Machine_learning", "machine learning"),
+    ("https://simple.wikipedia.org/wiki/Coffee", "coffee"),
+    # comparison
+    (
+        "https://en.wikipedia.org/wiki/Comparison_of_web_browsers",
+        "web browser comparison",
+    ),
+    (
+        "https://en.wikipedia.org/wiki/Comparison_of_text_editors",
+        "text editor comparison",
+    ),
+    # recipe
+    ("https://en.wikibooks.org/wiki/Cookbook:Pancake", "pancake recipe"),
+    ("https://en.wikibooks.org/wiki/Cookbook:Guacamole", "guacamole recipe"),
+]

backend/app/jobs/seed_runner.py

@@ -0,0 +1,88 @@
+"""Run the curated seed jobs to grow B's memory when idle.
+
+One pass audits every seed job with Agent B in learning mode (each gets a fresh,
+monotonic run index so patterns recur across distinct runs), then runs the janitor
+once to consolidate the diary into the playbook. A bot-blocked seed page degrades
+to a SERP-only audit (see fetch_page) rather than aborting the pass.
+
+The agent / janitor / diary are injectable so the orchestration is testable without
+live LLM calls.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+from typing import Protocol
+
+from pydantic import BaseModel
+
+from app.agents.agent_b import run_agent_b
+from app.jobs.seed_jobs import SEED_JOBS
+from app.memory.janitor import run_janitor
+from app.models import AgentRunResult
+from app.models.memory import PlaybookEntry
+from app.repositories.diary import DiaryRepository
+from app.tools.registry import build_default_registry
+
+logger = logging.getLogger("seed")
+
+AgentFn = Callable[..., Awaitable[AgentRunResult]]
+JanitorFn = Callable[[], Awaitable[list[PlaybookEntry]]]
+
+
+class RunCounter(Protocol):
+    async def next_run(self) -> int: ...
+
+
+class SeedResult(BaseModel):
+    jobs_run: int
+    playbook_size: int
+
+
+async def run_seed_pass(
+    *,
+    jobs: list[tuple[str, str]] | None = None,
+    passes: int = 1,
+    replay: bool = False,
+    agent: AgentFn | None = None,
+    janitor: JanitorFn | None = None,
+    diary: RunCounter | None = None,
+) -> SeedResult:
+    """Audit every seed job with learning on, then consolidate once."""
+    jobs = jobs if jobs is not None else SEED_JOBS
+    agent = agent or run_agent_b
+    janitor = janitor or run_janitor
+    diary = diary or DiaryRepository()
+    registry = build_default_registry(replay=replay)
+
+    jobs_run = 0
+    for _ in range(passes):
+        for url, keyword in jobs:
+            run_index = await diary.next_run()
+            await agent(
+                url,
+                keyword,
+                registry=registry,
+                replay=replay,
+                memory_on=True,
+                learn=True,
+                run_index=run_index,
+                persist=True,
+            )
+            jobs_run += 1
+
+    promoted = await janitor()
+    logger.info("seed pass done: %d jobs, %d rules promoted", jobs_run, len(promoted))
+    return SeedResult(jobs_run=jobs_run, playbook_size=len(promoted))
+
+
+async def run_idle_loop(*, interval_seconds: int, passes: int = 1) -> None:
+    """Forever: run one seed pass, then sleep. Gated by config; off by default."""
+    while True:
+        try:
+            await run_seed_pass(passes=passes)
+        except Exception:  # never let one bad pass kill the idle loop
+            logger.exception("seed pass failed; will retry next tick")
+        await asyncio.sleep(interval_seconds)

backend/tests/test_seed_runner.py

@@ -0,0 +1,48 @@
+"""Seed runner orchestration — verified without any live LLM call."""
+
+import pytest
+
+from app.jobs.seed_runner import run_seed_pass
+from app.models import AgentRunResult
+
+
+class _FakeDiary:
+    """Hands out monotonic run indices, like the real diary repo."""
+
+    def __init__(self) -> None:
+        self._n = 0
+
+    async def next_run(self) -> int:
+        n = self._n
+        self._n += 1
+        return n
+
+
+@pytest.mark.asyncio
+async def test_runs_every_job_with_learning_then_consolidates() -> None:
+    calls: list[tuple[str, str, int, bool]] = []
+
+    async def fake_agent(url, keyword, **kwargs) -> AgentRunResult:
+        calls.append((url, keyword, kwargs["run_index"], kwargs["learn"]))
+        return AgentRunResult(agent="B", url=url, keyword=keyword)
+
+    janitor_calls = 0
+
+    async def fake_janitor():
+        nonlocal janitor_calls
+        janitor_calls += 1
+        return []
+
+    jobs = [("https://a.test", "ka"), ("https://b.test", "kb")]
+    result = await run_seed_pass(
+        jobs=jobs,
+        passes=2,
+        agent=fake_agent,
+        janitor=fake_janitor,
+        diary=_FakeDiary(),
+    )
+
+    assert result.jobs_run == 4  # 2 jobs x 2 passes
+    assert janitor_calls == 1  # consolidate once, after the passes
+    assert all(learn for *_, learn in calls)  # learning on for every job
+    assert [run_index for *_, run_index, _ in calls] == [0, 1, 2, 3]  # monotonic

frontend/src/App.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useState, type FormEvent } from 'react'
 import './App.css'
-import { fetchDiary, fetchPlaybook, runAgents } from './api'
+import { fetchDiary, fetchPlaybook, runAgents, runSeed } from './api'
 import { AgentColumn } from './components/AgentColumn'
 import { MemoryPanel } from './components/MemoryPanel'
 import type { DiaryEntry, PlaybookEntry, RunResponse } from './types'
@@ -86,6 +86,13 @@ function MemoryPage() {
   const [playbook, setPlaybook] = useState<PlaybookEntry[] | null>(null)
   const [diary, setDiary] = useState<DiaryEntry[]>([])
   const [error, setError] = useState<string | null>(null)
+  const [seeding, setSeeding] = useState(false)
+
+  async function load() {
+    const [p, d] = await Promise.all([fetchPlaybook(), fetchDiary()])
+    setPlaybook(p)
+    setDiary(d)
+  }
 
   useEffect(() => {
     let active = true
@@ -102,10 +109,33 @@ function MemoryPage() {
     }
   }, [])
 
+  async function handleGrow() {
+    if (!confirm('Run the curated seed jobs live? This fetches each page and calls the LLM — slow and spends tokens.')) return
+    setSeeding(true)
+    setError(null)
+    try {
+      await runSeed(1)
+      await load()
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'seeding failed')
+    } finally {
+      setSeeding(false)
+    }
+  }
+
   if (error) return <p className="hint error">{error}</p>
   if (!playbook) return <p className="hint">loading memory…</p>
   return (
     <main className="learning">
+      <div>
+        <button onClick={handleGrow} disabled={seeding}>
+          {seeding ? 'Growing B’s memory…' : 'Grow B’s memory (run seed jobs)'}
+        </button>
+        <p className="hint">
+          Cycles a curated list of real pages with learning on, then consolidates. Live and slow;
+          run a few times so patterns recur and get promoted.
+        </p>
+      </div>
       <MemoryPanel playbook={playbook} diary={diary} />
     </main>
   )

frontend/src/api.ts

@@ -2,7 +2,7 @@
 // call raw fetch. Paths are relative to VITE_API_BASE (default `/api`), proxied
 // to the backend by Vite.
 
-import type { DiaryEntry, HealthResponse, PlaybookEntry, RunResponse } from './types'
+import type { DiaryEntry, HealthResponse, PlaybookEntry, RunResponse, SeedResult } from './types'
 
 const API_BASE = (import.meta.env.VITE_API_BASE as string | undefined) ?? '/api'
 
@@ -44,3 +44,23 @@ export async function runAgents(url: string, keyword: string): Promise<RunRespon
   }
   return (await response.json()) as RunResponse
 }
+
+// Work the curated seed jobs with learning on, then consolidate. Live + slow.
+export async function runSeed(passes = 1): Promise<SeedResult> {
+  const response = await fetch(`${API_BASE}/run/seed`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ passes }),
+  })
+  if (!response.ok) {
+    let message = `Seeding failed (HTTP ${response.status}).`
+    try {
+      const body = (await response.json()) as { detail?: string }
+      if (body.detail) message = body.detail
+    } catch {
+      /* non-JSON body — keep the generic message */
+    }
+    throw new Error(message)
+  }
+  return (await response.json()) as SeedResult
+}

frontend/src/types.ts

@@ -38,6 +38,11 @@ export interface RunResponse {
   note?: string | null // set when the page body couldn't be fetched (SERP-only run)
 }
 
+export interface SeedResult {
+  jobs_run: number
+  playbook_size: number
+}
+
 export interface PlaybookEntry {
   page_kind: string
   rec_type: string