python agent/run.py --mock   # first run
python agent/run.py --mock   # second run

grep -c "^## " agent/memory/episodic.md   # expect 2, after two runs -- one heading per run
python -c "
import sys; sys.path.insert(0, 'agent/retrieval')
from pathlib import Path
from search import search
print(len(search(Path('agent/memory/episodic.md'), 'PR waiting review')))
"   # expect a positive number; 0 would mean nothing was found

# Identity

Owner: <your name>
Purpose: track open pull requests waiting on my review, and tell me only
when one has waited more than 2 days.
Repos watched: you/example-repo
Reporting rule: silent if nothing is stale; otherwise list each stale PR once.

# Episodic Memory

Append-only. Each run appends one `## <ISO timestamp>` entry below this
line. Do not hand-edit past entries. Retrieval's recency scoring assumes
the log stays chronological.

"""Hybrid search over agent/memory/episodic.md: keyword overlap + recency
decay. No embeddings, no vector DB -- read every line before you trust it."""
import math, re
from datetime import datetime, timezone
from pathlib import Path

HEADER = re.compile(r"^## (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})$", re.MULTILINE)


def search(path: Path, query: str, k: int = 3, keyword_weight: float = 0.7) -> list[str]:
    text = path.read_text(encoding="utf-8") if path.exists() else ""
    matches = list(HEADER.finditer(text))
    entries = [
        (datetime.strptime(m.group(1), "%Y-%m-%dT%H:%M:%S").replace(tzinfo=timezone.utc),
         text[m.start():(matches[i + 1].start() if i + 1 < len(matches) else len(text))].strip())
        for i, m in enumerate(matches)
    ]
    if not entries:
        return []
    q_terms = set(re.findall(r"[a-z0-9]+", query.lower()))
    now = datetime.now(timezone.utc)
    scored = []
    for ts, body in entries:
        b_terms = set(re.findall(r"[a-z0-9]+", body.lower()))
        kw = len(q_terms & b_terms) / len(q_terms) if q_terms else 0.0
        recency = math.exp(-max((now - ts).total_seconds() / 86400, 0) / 14.0)
        scored.append((keyword_weight * kw + (1 - keyword_weight) * recency, body))
    scored.sort(key=lambda pair: pair[0], reverse=True)
    return [body for score, body in scored[:k] if score > 0]

#!/usr/bin/env python3
"""Wrapper: the only file allowed to hold GITHUB_TOKEN. Run as a
subprocess -- callers see only this script's stdout (a JSON PR list),
never the token, never the raw API response."""
import json, os, sys, urllib.request

MOCK_PRS = [
    {"repo": "you/example-repo", "number": 42, "title": "Add retry to webhook handler", "waiting_days": 3},
    {"repo": "you/example-repo", "number": 47, "title": "Fix flaky auth test", "waiting_days": 1},
]


def main() -> None:
    token = os.environ.get("GITHUB_TOKEN")
    if token and "--mock" not in sys.argv:
        url = "https://api.github.com/search/issues?q=is:open+is:pr+review-requested:@me"
        req = urllib.request.Request(url, headers={"Authorization": f"Bearer {token}"})
        data = json.load(urllib.request.urlopen(req, timeout=10))
        prs = [{"repo": i["repository_url"].split("/repos/")[-1], "number": i["number"],
                "title": i["title"], "waiting_days": None} for i in data.get("items", [])]
    else:
        prs = MOCK_PRS
    print(json.dumps(prs))


if __name__ == "__main__":
    main()

---
name: triage-prs
description: Decide which open PRs are worth interrupting the owner about.
---

Use after `agent/tools/github_prs.py` returns its PR list.

Rule: report a PR only if `waiting_days > 2`. Reporting every open PR
trains the owner to ignore the report.

Output one line per stale PR: `<repo>#<number>: <title> (<waiting_days>d)`.
If nothing is stale, report nothing but a one-line confirmation the check
ran -- silence is correct, not a failure.

---
name: log-entry
description: Format one episodic memory entry so retrieval can parse it.
---

Heading: a level-2 heading holding only an ISO 8601 UTC timestamp --
`## 2026-08-19T09:00:00`.

Body: always include `Ran: <what ran>` and a one-line result summary.
Never edit or delete a past entry -- the log is append-only.

End with one blank line before the next `## ` heading, or
`agent/retrieval/search.py` merges two entries into one.

#!/usr/bin/env python3
"""Single entry point. Run: python agent/run.py [--mock]
One pass of Remember -> Retrieve -> Act -> Report, then exit. No model
call here -- point one at act()/report() once you're ready to replace
the hardcoded triage-prs rule with judgment."""
import json, re, subprocess, sys
from datetime import datetime, timezone
from pathlib import Path

AGENT_DIR = Path(__file__).parent
IDENTITY = AGENT_DIR / "memory" / "identity.md"
EPISODIC = AGENT_DIR / "memory" / "episodic.md"
FRONTMATTER = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)


def list_skills() -> list[dict]:
    """Progressive disclosure step 1: name + description only, every run."""
    out = []
    for path in sorted((AGENT_DIR / "skills").glob("*/SKILL.md")):
        meta_block = FRONTMATTER.match(path.read_text(encoding="utf-8")).group(1)
        meta = dict(line.split(":", 1) for line in meta_block.splitlines() if ":" in line)
        out.append({"name": meta["name"].strip(), "description": meta["description"].strip()})
    return out

def retrieve(query: str, k: int = 3) -> list[str]:
    sys.path.insert(0, str(AGENT_DIR / "retrieval"))
    from search import search
    return search(EPISODIC, query, k=k)

def act(mock: bool) -> list[dict]:
    cmd = [sys.executable, str(AGENT_DIR / "tools" / "github_prs.py")]
    result = subprocess.run(cmd + (["--mock"] if mock else []), capture_output=True, text=True, check=True)
    return json.loads(result.stdout)

def report(prs: list[dict], history: list[str]) -> None:
    stale = [pr for pr in prs if (pr.get("waiting_days") or 0) > 2]  # triage-prs rule
    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S")
    lines = [f"## {ts}", "Ran: triage-prs", f"Open PRs seen: {len(prs)}", f"Waiting >2 days: {len(stale)}"]
    lines += [f"- {p['repo']}#{p['number']}: {p['title']} ({p['waiting_days']}d)" for p in stale]
    with EPISODIC.open("a", encoding="utf-8") as f:
        f.write("\n".join(lines) + "\n\n")
    print(f"REPORT: {len(stale)} PR(s) waiting on you >2 days:" if stale else "REPORT: nothing waiting. Staying quiet.")
    for p in stale:
        print(f"  - {p['repo']}#{p['number']}: {p['title']}")
    if history:
        print(f"(context: {len(history)} related past run(s) in episodic memory)")

def main() -> None:
    assert IDENTITY.read_text(encoding="utf-8").strip(), "agent/memory/identity.md is empty -- fill it in first"
    skills = list_skills()
    print(f"Loaded {len(skills)} skill(s): {', '.join(s['name'] for s in skills)}")
    history = retrieve("PR waiting review", k=3)
    report(act(mock="--mock" in sys.argv), history)

if __name__ == "__main__":
    main()