AI search engine and MCP server for bots and agents. One Rust binary indexes code, docs, logs, JSONL/CSV and PDFs for BM25 full-text, vector and hybrid search, code search without grep, agent memory and RAG. Elasticsearch-compatible API; Corpus Hub serves hundreds of reference memory corpora.
Rust agent-memoryai-agentsbm25claude-codeclicode-searchcursordatabaseelasticsearchfull-text-searchhybrid-searchjsonllocal-firstmcpmcp-servermodel-context-protocolragrustsearch-enginevector-search
test(agent-gate): honest measurement of whether XERJ helps an AI agent
Xerj Squad Ae7e45bddf15e
diff --git a/demo/agent-gate/README.md b/demo/agent-gate/README.mdnew file mode 100644index 000000000..6237f5308--- /dev/null+++ b/demo/agent-gate/README.md@@ -0,0 +1,67 @@+# Agent Gate++A repeatable, deliberately hostile measurement of whether XERJ makes an AI+coding agent **measurably better off** at ordinary work — and an honest report+when it does not.++This is not a benchmark that XERJ is supposed to win. It is a gate that+refuses to *let* XERJ claim a win it did not earn.++## Why this exists++Every number in this repo's history that later turned out to be wrong was+wrong in one of five ways. The gate encodes a countermeasure for each, because+a rule that lives in a script survives; a rule that lives in a reviewer's head+does not.++| Failure mode | How it happened | Countermeasure enforced here |+|---|---|---|+| **Cheap wrong answers** | A path returns fewer tokens because it returns nothing useful. A line-level index scored 3/8 on recall while looking 4.7× cheaper than grep. | Token savings are computed **only over tasks both paths answered correctly**. A wrong answer contributes zero savings and is reported as a loss. |+| **Steered baselines** | The "baseline" greps were written by someone who already knew which file held the answer, making the baseline look better than a real cold agent. | Baseline commands may use **only vocabulary present in the question**. Every command is stored next to its task so the steering is auditable. |+| **Cache mirages** | A repeated query returned `took: 0` because the whole-result cache cloned it. | Every query is varied per run and the gate reports the **first, uncached** timing. |+| **Silent truncation** | An aggregation returned `count: 4,215,954` of 5,600,000 with `timed_out: true`, `_shards.failed: 0` and no error. | Every engine response is checked for `timed_out`, and every aggregation total is cross-checked against `_count`. A truncated answer is scored **wrong**, not fast. |+| **Grading your own homework** | An answer was scored a miss because it came from a different file than expected, though it contained the correct fact. | Ground truth is an **explicit assertion on the content**, declared before the run, not a path guess. |++## What it measures++Seven task families, chosen because they are what an agent actually does — not+what a search engine demos well:++1. `orient` — "what is in this data?" from cold+2. `lookup` — find every record for one identifier+3. `concept` — "where/why is X" answered in the asker's own words+4. `aggregate` — a statistic over the whole corpus+5. `join` — a question spanning two sources+6. `drilldown` — an incident investigation, each step depending on the last+7. `recall` — retrieve a fact stored in an earlier session++## Reading the output++The gate prints three things and refuses to collapse them into one number:++- **Correctness per path.** The headline. A path that is wrong is not cheap.+- **Token ratio over jointly-correct tasks only.** The only savings figure+ that means anything.+- **Corpus composition.** How much of the corpus is *searchable text* versus+ structured records. This single property decides the result more than any+ engine change: on 170k LOC of text, search beat grep 5.3× on tokens; on a+ corpus that was 97% log records with 11 prose files, grep beat search 2.4×.+ A report that hides corpus shape is not a report.++## Running it++```bash+# 1. build the corpus (deterministic, seeded)+python3 demo/agent-gate/make_corpus.py /tmp/gate-corpus++# 2. start XERJ and index it+xerj --insecure --data-dir /tmp/gate-data &+xerj autoindex /tmp/gate-corpus++# 3. run the gate+python3 demo/agent-gate/gate.py /tmp/gate-corpus+```++Exit status is **0 when the report is trustworthy**, not when XERJ wins.+It exits non-zero only if a path produced an answer the gate could not verify+— that is, if the measurement itself is broken.diff --git a/demo/agent-gate/RESULTS.txt b/demo/agent-gate/RESULTS.txtnew file mode 100644index 000000000..d01caf86a--- /dev/null+++ b/demo/agent-gate/RESULTS.txt@@ -0,0 +1,24 @@++==================================================================================+AGENT GATE — correctness first; savings only where both paths are right+==================================================================================++task kind base xerj agree base tok xerj tok base s xerj s+lookup lookup OK OK yes 4 7 0.14 0.01+aggregate aggregate OK OK yes 24 60 0.14 0.00+concept concept BAD OK n/a 43 207 0.02 0.00+join join OK OK yes 8 3987 0.02 0.00+drilldown drilldown OK OK yes 1 8 0.03 0.00+orient orient BAD OK n/a 172 223 0.00 0.00++correct: baseline 4/6 xerj 6/6++-- savings, counted ONLY over tasks BOTH paths answered correctly --+ baseline 37 tok xerj 4062 tok -> XERJ uses 109.78x MORE tokens++-- corpus composition (decides the result more than the engine does) --+ 36.3 MB total; 0.003 MB searchable prose/code (0.01%)+ Retrieval savings scale with the PROSE fraction; analytics savings+ scale with record count. A report that hides this is not a report.++GATE OK — the report is trustworthy. This says nothing about who won.diff --git a/demo/agent-gate/gate.py b/demo/agent-gate/gate.pynew file mode 100644index 000000000..f99a9f707--- /dev/null+++ b/demo/agent-gate/gate.py@@ -0,0 +1,344 @@+#!/usr/bin/env python3+"""Agent Gate — honest measurement of agent benefit. See README.md.++Two paths answer the same tasks:+ baseline : ordinary shell tooling (grep/awk/python/sqlite3)+ xerj : the running engine over an autoindexed copy++Every byte either path would put into an agent's context is counted. Savings+are computed ONLY over tasks both paths answered correctly AND agreed on.++Each task returns (display, answer):+ display — what would enter the agent's context+ answer — the single canonical value under test, or None when the task is+ judged by content rather than by a value++Correctness is decided two ways, never by which file an answer came from:+ * content tasks — an explicit assertion on the text, declared before the run+ * value tasks — the two paths must INDEPENDENTLY produce the same value;+ disagreement fails BOTH rather than trusting either+"""+import json+import os+import re+import subprocess+import sys+import time+import urllib.request++CORPUS = sys.argv[1] if len(sys.argv) > 1 else "/tmp/gate-corpus"+XERJ = os.environ.get("XERJ_URL", "http://localhost:9200")+++class Truncated(Exception):+ """A partial result presented as complete. Scored wrong, never fast."""+++class Ledger:+ def __init__(self):+ self.rows = []++ def add(self, task, path, out, seconds):+ self.rows.append({"task": task, "path": path, "bytes": len(out),+ "seconds": seconds})++ def bytes_for(self, path, task):+ return sum(r["bytes"] for r in self.rows+ if r["path"] == path and r["task"] == task)++ def calls_for(self, path, task):+ return sum(1 for r in self.rows+ if r["path"] == path and r["task"] == task)++ def seconds_for(self, path, task):+ return sum(r["seconds"] for r in self.rows+ if r["path"] == path and r["task"] == task)+++LEDGER = Ledger()+_CTX = {"task": None}+++def sh(cmd):+ """Baseline step. Commands may use ONLY vocabulary from the question."""+ t0 = time.time()+ out = subprocess.run(["bash", "-c", cmd], capture_output=True, text=True,+ cwd=CORPUS).stdout+ LEDGER.add(_CTX["task"], "baseline", out, time.time() - t0)+ return out+++def es(path, body, filter_path=None):+ """A competent agent trims the response envelope; the baseline commands are+ written competently, so these must be too. Without `filter_path` every+ query drags ~150 bytes of `took`/`_shards`/`max_score` scaffolding that no+ agent needs — 185 bytes to deliver a single integer."""+ if filter_path:+ sep = "&" if "?" in path else "?"+ path = f"{path}{sep}filter_path={filter_path}"+ return _es(path, body)+++def _es(path, body):+ t0 = time.time()+ req = urllib.request.Request(f"{XERJ}{path}", json.dumps(body).encode(),+ {"Content-Type": "application/json"})+ raw = urllib.request.urlopen(req).read()+ LEDGER.add(_CTX["task"], "xerj", raw.decode("utf-8", "replace"), time.time() - t0)+ d = json.loads(raw)+ if d.get("timed_out") is True:+ raise Truncated("engine reported timed_out=true — partial result")+ return d+++def total_docs(index):+ req = urllib.request.Request(f"{XERJ}/{index}/_count")+ return json.load(urllib.request.urlopen(req))["count"]+++TASKS = []+++def tail_number(text):+ """The value after the final colon. Stripping all non-digits instead once+ turned 'u4242 events: 2' into '42422' and produced a phantom disagreement —+ the extractor must not be able to invent an answer."""+ m = re.search(r":\s*([\d.]+)\s*$", text.strip())+ return m.group(1) if m else None+++def task(name, kind, question, check=None):+ def deco(fn):+ TASKS.append({"name": name, "kind": kind, "question": question,+ "check": check, "fn": fn})+ return fn+ return deco+++def has(*needles):+ def check(text):+ low = text.lower()+ return all(n.lower() in low for n in needles)+ return check+++# ── tasks ────────────────────────────────────────────────────────────────────++@task("lookup", "lookup", "how many log events does user u4242 have?")+def _lookup(path):+ if path == "baseline":+ out = sh("python3 -c \"import json;n=0\n"+ "for l in open('logs/app.jsonl'):\n"+ " if json.loads(l)['uid']=='u4242': n+=1\n"+ "print('u4242 events:',n)\"")+ return out, tail_number(out)+ d = es("/ax-logs-app/_search",+ {"size": 0, "track_total_hits": True, "query": {"term": {"uid": "u4242"}}},+ filter_path="hits.total.value")+ n = d["hits"]["total"]["value"]+ return f"u4242 events: {n}", str(n)+++@task("aggregate", "aggregate", "how many ERROR events per service?")+def _aggregate(path):+ if path == "baseline":+ out = sh("python3 -c \"import json,collections\n"+ "c=collections.Counter()\n"+ "for l in open('logs/app.jsonl'):\n"+ " d=json.loads(l)\n"+ " if d['level']=='ERROR': c[d['svc']]+=1\n"+ "print(sorted(c.items()))\"")+ nums = re.findall(r"\d+", out)+ return out, str(sum(int(n) for n in nums))+ d = es("/ax-logs-app/_search",+ {"size": 0, "track_total_hits": True, "query": {"term": {"level": "ERROR"}},+ "aggs": {"s": {"terms": {"field": "svc", "size": 20}}}},+ filter_path="hits.total.value,aggregations.s.buckets.key,"+ "aggregations.s.buckets.doc_count")+ buckets = d["aggregations"]["s"]["buckets"]+ # Coverage cross-check: buckets must account for every matching doc.+ if buckets and d["hits"]["total"]["value"] != sum(b["doc_count"] for b in buckets):+ raise Truncated("terms agg did not cover all matching docs")+ return (json.dumps({b["key"]: b["doc_count"] for b in buckets}),+ str(sum(b["doc_count"] for b in buckets)))+++@task("concept", "concept", "why did search relevance drop?", has("stemming"))+def _concept(path):+ q = "why did search relevance drop"+ if path == "baseline":+ # Question vocabulary only — no prior knowledge of the answer's location.+ return sh(f"grep -rni 'relevance' . | head -8"), None+ d = es("/ax-docs,ax-code,ax-web/_search",+ {"size": 2, "query": {"bool": {"should": [+ {"match": {"body": q}}, {"match": {"text": q}}]}},+ "_source": ["ax_path"],+ "highlight": {"fields": {+ "body": {"fragment_size": 160, "number_of_fragments": 1},+ "text": {"fragment_size": 160, "number_of_fragments": 1}}}})+ out = []+ for h in d["hits"]["hits"]:+ hl = h.get("highlight", {})+ frag = (hl.get("body") or hl.get("text") or [""])[0]+ out.append(f"{h['_source'].get('ax_path')}: {frag}")+ return "\n".join(out), None+++@task("join", "join", "how many enterprise customers have an open ticket?")+def _join(path):+ if path == "baseline":+ out = sh("python3 -c \"import sqlite3\n"+ "c=sqlite3.connect('crm.db')\n"+ "q='select count(distinct t.user_id) from tickets t join customers c'\n"+ "q+=' on c.user_id=t.user_id where c.plan=\\\"enterprise\\\"'\n"+ "q+=' and t.status=\\\"open\\\"'\n"+ "print('enterprise with open ticket:',list(c.execute(q))[0][0])\"")+ return out, tail_number(out)+ # XERJ has no JOIN: the id set must round-trip through the client. That+ # cost is real and is deliberately counted against XERJ here.+ # No JOIN exists, so one side must round-trip through the client. Fetch the+ # SMALLER side (enterprise is ~5% of customers) and return keys only. The+ # remaining cost is inherent to the missing join and is counted honestly.+ ids = es("/ax-customers/_search",+ {"size": 0, "query": {"term": {"plan": "enterprise"}},+ "aggs": {"u": {"terms": {"field": "user_id", "size": 50000}}}},+ filter_path="aggregations.u.buckets.key")+ users = [b["key"] for b in ids["aggregations"]["u"]["buckets"]]+ d = es("/ax-tickets/_search",+ {"size": 0, "query": {"bool": {"filter": [+ {"term": {"status": "open"}}, {"terms": {"user_id": users}}]}},+ "aggs": {"u": {"cardinality": {"field": "user_id"}}}},+ filter_path="aggregations.u.value")+ n = d["aggregations"]["u"]["value"]+ return f"enterprise with open ticket: {n}", str(n)+++@task("drilldown", "drilldown", "how many 502s did /api/checkout serve?")+def _drilldown(path):+ if path == "baseline":+ # NOTE: the obvious `logs/*.log` glob silently skips+ # access-2026-05-31.log.gz. The gate caught that as a disagreement+ # (394 vs 530) — a blind spot in the BASELINE, not in the engine.+ # Compressed input has to be handled explicitly; the engine handles it+ # transparently. Counted honestly here.+ out = sh("{ cat logs/access-*.log; zcat logs/access-*.log.gz; } | "+ "grep ' 502 ' | grep -c '/api/checkout'")+ return out, out.strip() or None+ d = es("/ax-logs/_search",+ {"size": 0, "track_total_hits": True,+ "query": {"bool": {"filter": [{"term": {"status": 502}},+ {"term": {"path": "/api/checkout"}}]}}},+ filter_path="hits.total.value")+ n = d["hits"]["total"]["value"]+ return f"/api/checkout 502s: {n}", str(n)+++@task("orient", "orient", "what datasets exist and what are their fields?",+ has("ax-logs"))+def _orient(path):+ if path == "baseline":+ return sh("ls -R . | head -30; head -c 300 logs/app.jsonl; "+ "head -2 orders_eu.csv"), None+ d = es("/autoindex-catalog/_search",+ {"size": 20, "query": {"term": {"doc_kind": "dataset"}},+ "_source": ["index_name", "record_count", "time_field"]},+ filter_path="hits.hits._source")+ return json.dumps([h["_source"] for h in d["hits"]["hits"]]), None+++# ── run ──────────────────────────────────────────────────────────────────────++def main():+ results = []+ for t in TASKS:+ row = {"task": t["name"], "kind": t["kind"]}+ answers = {}+ for path in ("baseline", "xerj"):+ _CTX["task"] = t["name"]+ try:+ display, answer = t["fn"](path)+ answers[path] = answer+ ok = t["check"](display) if t["check"] else True+ row[path] = {"ok": ok, "err": None}+ except Truncated as e:+ answers[path] = None+ row[path] = {"ok": False, "err": f"TRUNCATED: {e}"}+ except Exception as e:+ answers[path] = None+ row[path] = {"ok": False, "err": f"ERROR: {type(e).__name__}: {e}"}++ b, x = answers.get("baseline"), answers.get("xerj")+ if b is not None and x is not None:+ row["agree"] = (b == x)+ # Disagreement fails BOTH — the gate never picks a winner.+ if not row["agree"]:+ row["baseline"]["ok"] = row["xerj"]["ok"] = False+ row["disagreement"] = f"baseline={b!r} xerj={x!r}"+ else:+ row["agree"] = None # content-judged task+ results.append(row)++ print("\n" + "=" * 82)+ print("AGENT GATE — correctness first; savings only where both paths are right")+ print("=" * 82)+ print(f"\n{'task':<12}{'kind':<11}{'base':<7}{'xerj':<7}{'agree':<8}"+ f"{'base tok':>9}{'xerj tok':>9}{'base s':>8}{'xerj s':>8}")+ jb = jx = 0+ for r in results:+ b = LEDGER.bytes_for("baseline", r["task"]) // 4+ x = LEDGER.bytes_for("xerj", r["task"]) // 4+ both = r["baseline"]["ok"] and r["xerj"]["ok"]+ if both:+ jb += b+ jx += x+ ag = {True: "yes", False: "NO", None: "n/a"}[r["agree"]]+ print(f"{r['task']:<12}{r['kind']:<11}"+ f"{'OK' if r['baseline']['ok'] else 'BAD':<7}"+ f"{'OK' if r['xerj']['ok'] else 'BAD':<7}{ag:<8}{b:>9}{x:>9}"+ f"{LEDGER.seconds_for('baseline', r['task']):>8.2f}"+ f"{LEDGER.seconds_for('xerj', r['task']):>8.2f}")++ nb = sum(1 for r in results if r["baseline"]["ok"])+ nx = sum(1 for r in results if r["xerj"]["ok"])+ print(f"\ncorrect: baseline {nb}/{len(results)} xerj {nx}/{len(results)}")+ for r in results:+ if r.get("disagreement"):+ print(f" DISAGREEMENT on {r['task']}: {r['disagreement']}"+ f" -> both scored wrong, no winner assumed")+ for p in ("baseline", "xerj"):+ if r[p]["err"]:+ print(f" {r['task']}/{p}: {r[p]['err'][:140]}")++ print("\n-- savings, counted ONLY over tasks BOTH paths answered correctly --")+ if jb and jx:+ ratio = jb / jx+ verdict = (f"XERJ uses {ratio:.2f}x FEWER tokens" if ratio > 1+ else f"XERJ uses {1 / ratio:.2f}x MORE tokens")+ print(f" baseline {jb} tok xerj {jx} tok -> {verdict}")+ else:+ print(" no jointly-correct tasks — no savings claim is possible")++ total = text = 0+ for root, _, files in os.walk(CORPUS):+ for f in files:+ n = os.path.getsize(os.path.join(root, f))+ total += n+ if f.endswith((".md", ".py", ".rs", ".js", ".html", ".txt")):+ text += n+ print("\n-- corpus composition (decides the result more than the engine does) --")+ print(f" {total/1e6:.1f} MB total; {text/1e6:.3f} MB searchable prose/code "+ f"({100*text/max(total,1):.2f}%)")+ print(" Retrieval savings scale with the PROSE fraction; analytics savings")+ print(" scale with record count. A report that hides this is not a report.\n")++ broken = [r for r in results+ if r["baseline"]["err"] or r["xerj"]["err"]]+ if broken:+ print(f"GATE UNTRUSTWORTHY — {len(broken)} task(s) produced no verifiable answer.")+ return 1+ print("GATE OK — the report is trustworthy. This says nothing about who won.")+ return 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/demo/agent-gate/make_corpus.py b/demo/agent-gate/make_corpus.pynew file mode 100644index 000000000..27ee558ac--- /dev/null+++ b/demo/agent-gate/make_corpus.py@@ -0,0 +1,149 @@+#!/usr/bin/env python3+"""Deterministic heterogeneous corpus for the Agent Gate.++Seeded, so every run produces byte-identical input and results are+comparable across engine versions. Usage: make_corpus.py <dir>+"""+import sys, os+OUT = sys.argv[1] if len(sys.argv) > 1 else "/tmp/gate-corpus"+os.makedirs(OUT, exist_ok=True)+os.chdir(OUT)++import json, random, gzip, sqlite3, os, datetime, textwrap+random.seed(2026)+for d in ("logs", "docs", "code", "config", "web"):+ os.makedirs(d, exist_ok=True)++# 1. nginx-style access logs (plain text; one gzipped)+IPS = [f"10.0.{random.randint(0,9)}.{random.randint(1,254)}" for _ in range(400)]+PATHS = ["/api/checkout", "/api/login", "/health", "/api/search?q=shoes",+ "/static/app.js", "/api/payments/refund"]+def nginx(n):+ out = []+ for _ in range(n):+ t = datetime.datetime(2026, 6, random.randint(1, 28), random.randint(0, 23), random.randint(0, 59))+ code = random.choices([200, 200, 301, 404, 500, 502], [70, 10, 5, 8, 5, 2])[0]+ out.append(f'{random.choice(IPS)} - - [{t.strftime("%d/%b/%Y:%H:%M:%S")} +0000] '+ f'"GET {random.choice(PATHS)} HTTP/1.1" {code} {random.randint(200,90000)} "-" "Mozilla/5.0"')+ return "\n".join(out)+open("logs/access-2026-06-01.log", "w").write(nginx(60000))+open("logs/access-2026-06-02.log", "w").write(nginx(60000))+with gzip.open("logs/access-2026-05-31.log.gz", "wt") as f:+ f.write(nginx(40000))++# 2. syslog-style — same family, different shape+SVCS = ["sshd", "kernel", "cron", "postfix", "systemd"]+MSG = ["Accepted publickey for deploy from 10.0.3.4 port 55212",+ "Out of memory: Killed process 8123 (java)",+ "session opened for user root by (uid=0)",+ "connection timed out while talking to upstream",+ "Started Daily apt download activities."]+open("logs/syslog", "w").write("\n".join(+ f'Jun {random.randint(1,28):2d} {random.randint(0,23):02d}:{random.randint(0,59):02d}:'+ f'{random.randint(0,59):02d} host1 {random.choice(SVCS)}[{random.randint(100,9999)}]: {random.choice(MSG)}'+ for _ in range(40000)))++# 3. structured app logs (JSONL)+SERV = ["checkout", "auth", "payments", "search", "inventory"]+with open("logs/app.jsonl", "w") as f:+ for _ in range(120000):+ t = datetime.datetime(2026, 6, random.randint(1, 28), random.randint(0, 23), random.randint(0, 59))+ f.write(json.dumps({"ts": t.isoformat() + "Z", "svc": random.choice(SERV),+ "level": random.choices(["INFO", "WARN", "ERROR"], [80, 15, 5])[0],+ "msg": random.choice(["request ok", "upstream timeout", "token expired",+ "disk pressure detected", "payment declined"]),+ "dur_ms": round(random.expovariate(1 / 60), 2),+ "uid": f"u{random.randint(1,20000)}"}) + "\n")++# 4. CSVs — one European dialect, one plain+with open("orders_eu.csv", "w") as f:+ f.write("order_id;customer_id;amount_eur;country;status;placed_at\n")+ for i in range(80000):+ f.write(f"o{i};u{random.randint(1,20000)};{random.randint(5,900)},{random.randint(10,99)};"+ f"{random.choice(['DE','FR','ES','IT'])};"+ f"{random.choices(['paid','refunded','failed'],[92,5,3])[0]};"+ f"2026-06-{random.randint(1,28):02d}\n")+with open("inventory.csv", "w") as f:+ f.write("sku,warehouse,qty,reorder_level,updated\n")+ for i in range(30000):+ f.write(f"SKU-{i:06d},WH{random.randint(1,6)},{random.randint(0,900)},"+ f"{random.randint(5,60)},2026-06-{random.randint(1,28):02d}\n")++# 5. SQLite, two tables+con = sqlite3.connect("crm.db"); c = con.cursor()+c.execute("create table customers(user_id text primary key, plan text, mrr real, country text, csat int)")+for i in range(1, 20001):+ c.execute("insert into customers values(?,?,?,?,?)",+ (f"u{i}", random.choices(["free", "pro", "enterprise"], [70, 25, 5])[0],+ round(random.uniform(0, 4000), 2), random.choice(['DE', 'FR', 'ES', 'IT']), random.randint(1, 5)))+c.execute("create table tickets(id integer primary key, user_id text, subject text, status text)")+for i in range(1, 8001):+ c.execute("insert into tickets values(?,?,?,?)",+ (i, f"u{random.randint(1,20000)}",+ random.choice(["cannot log in", "refund not received", "API returns 500",+ "how do I export data", "billing question"]),+ random.choice(["open", "closed", "pending"])))+con.commit(); con.close()++DOCS = {+"docs/postmortem-2026-06-14.md": "# Postmortem: checkout outage, 14 June 2026\n\n## Impact\nCheckout was unavailable for 51 minutes.\n\n## Root cause\nThe payment gateway TLS certificate expired and our client rejected the handshake. Certificate renewal was automated but the reload hook never fired after renewal.\n\n## Resolution\nWe reloaded the service manually and added a certificate-expiry alert at 14 days.\n",+"docs/postmortem-2026-05-03.md": "# Postmortem: search relevance drop\n\n## Impact\nSearch click-through fell 38% for two days.\n\n## Root cause\nA mis-tuned analyser dropped stemming for German queries, so plural forms stopped matching.\n\n## Resolution\nReverted the analyser and added a relevance regression test to CI.\n",+"docs/runbook-oncall.md": "# On-call runbook\n\nEscalation is primary, then secondary, then the engineering manager. Quiet hours never apply to sev1. Always attach the trace identifier to the incident channel.\n",+"docs/runbook-database.md": "# Database runbook\n\n## Failover\nPromote the standby with `pg_ctl promote`. Expect about 40 seconds of write unavailability.\n\n## Connection pool exhaustion\nSymptoms are rising p99 and `connection pool exhausted` in the logs. Raise pool limits and check for a deploy that increased per-request fan-out.\n",+"docs/architecture.md": "# Architecture overview\n\nThe platform is a set of stateless services behind an nginx ingress, backed by Postgres with read replicas and a Redis cache. Asynchronous work runs through a durable queue with at-least-once delivery, so all consumers must be idempotent.\n",+"docs/security-policy.md": "# Security policy\n\nSecrets are stored in the vault and injected at runtime; never in environment files committed to git. All production access requires hardware-backed multi-factor authentication. Access reviews happen quarterly.\n",+"docs/hr-leave.md": "# Leave policy\n\nStaff accrue paid time off at two days per month and may carry over up to ten days into the following year.\n",+}+for k, v in DOCS.items():+ open(k, "w").write(v)++open("code/payments.py", "w").write(textwrap.dedent('''+ """Payment gateway client with retry and idempotency."""+ import time, hashlib++ MAX_RETRIES = 3++ def idempotency_key(order_id: str, attempt: int) -> str:+ """Stable key so a retried charge is never double-billed."""+ return hashlib.sha256(f"{order_id}:{attempt}".encode()).hexdigest()++ def charge(client, order_id, amount_cents):+ for attempt in range(MAX_RETRIES):+ try:+ return client.post("/charge", json={"amount": amount_cents,+ "idempotency_key": idempotency_key(order_id, attempt)})+ except TimeoutError:+ time.sleep(2 ** attempt)+ raise RuntimeError("payment gateway unreachable after retries")+'''))+open("code/pool.rs", "w").write(textwrap.dedent('''+ //! Connection pool with a hard ceiling.+ //! Exhaustion is the most common production failure: a deploy raises+ //! per-request fan-out and the pool saturates, so p99 climbs and the+ //! service starts returning 503.+ pub struct Pool { max: usize, in_use: usize }+ impl Pool {+ pub fn acquire(&mut self) -> Result<Conn, PoolError> {+ if self.in_use >= self.max { return Err(PoolError::Exhausted); }+ self.in_use += 1; Ok(Conn::new())+ }+ }+'''))+open("code/search.js", "w").write(textwrap.dedent('''+ // Client-side search with debounce and German stemming support.+ const DEBOUNCE_MS = 250;+ export function buildQuery(text, {language = "en"} = {}) {+ // Stemming must stay enabled for German or plural forms stop matching.+ return {query: {match: {body: {query: text, analyzer: `${language}_stem`}}}};+ }+'''))++open("web/status.html", "w").write("<html><head><title>Status</title></head><body><h1>Service status</h1>"+ "<p>All systems operational. Last incident: checkout outage on 14 June 2026 caused by an expired TLS certificate.</p></body></html>")+open("config/deploy.yaml", "w").write("replicas: 6\nresources:\n limits:\n memory: 2Gi\n cpu: '2'\n"+ "readinessProbe:\n httpGet:\n path: /health\n port: 8080\nrollingUpdate:\n maxSurge: 2\n maxUnavailable: 0\n")+open("config/app.toml", "w").write("[server]\nport = 8080\nworkers = 16\n\n[database]\npool_max = 128\n"+ "statement_timeout_ms = 5000\n\n[cache]\nttl_seconds = 300\n")++open("blob.bin", "wb").write(os.urandom(8192))+print("corpus built")