goldenreq 0.3.0__tar.gz

goldenreq-0.3.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: goldenreq
+Version: 0.3.0
+Summary: The acceptance gate for goldenization: gauges FILE requests carrying receipts; a handler ACCEPTS/REJECTS; only an accept fires the promotion effect. Nothing self-promotes.
+Requires-Python: >=3.11

goldenreq-0.3.0/README.md

@@ -0,0 +1,51 @@
+# goldenreq — the acceptance gate for goldenization
+
+**The gauge is not the handler.** A *gauge* is an internal self-assessment — the
+bandit's 2×🏆 on a constructed chain, a rulecatcher candidate rule, a forged
+template, a personapack `activation_grade` claim. A gauge can detect quality; it
+may **never** certify itself into golden/adopted/canon. That certification is a
+*handler*'s job — an external acceptance authority. `goldenreq` is that gate.
+
+The two-knob / CC loop is acceptable **only if** goldenization goes through this
+gate. Before, chainaios's bandit rule told the agent to self-fold a 2×🏆 chain
+into golden — self-certification. Now the rule says: **file a goldenization
+request; promotion happens only on an accepted verdict.**
+
+## The flow
+
+```
+gauge  ──file_request(kind, candidate_id, evidence, requested_promotion, requester)──►  queue (pending)
+                                                                                          │
+handler ──accept(request_id, by, reason) ──► fires the promotion effect ──► golden / grade-bump / …
+        └─reject(request_id, by, reason) ──► NO effect; reason recorded (a hard negative)
+```
+
+- **Requests carry receipts.** `evidence` is the graded KB notes / cert ids /
+  forge reports behind the claim. An unevidenced ask is a weak ask.
+- **Verdicts are the seed corpus** for the learned acceptance model that will
+  one day staff this gate automatically. **Rejections (with reasons) are its
+  hard negatives.** No trace → no handler → not annealable, only believable.
+
+## Kinds → effects
+
+| kind | gauge upstream | effect on accept |
+|---|---|---|
+| `chain-golden` | a bandit chain earned 🏆 twice | append an `ACCEPTED-BY` marker into the GBA KB note (never rewrites agent notes) |
+| `pack-grade-bump` | a personapack PackEntry | **pure** helper returns the new `activation_grade`; personapack applies it |
+| `rule-adopt` | a rulecatcher candidate | **stub** → points at `rulecatcher.engine.adopt_rules` (no fake integration) |
+| `template-promote` | a forged language/template | **stub** → no canonical-template promotion API to call yet |
+
+## Record shape
+
+The verdict record mirrors `base/acceptance`'s `acceptance.schema.Verdict`
+(read via `git show acceptance-handler:…`) so the verdicts JSONL is drop-in for
+that reader — **by shape, not by import** (no cross-branch coupling). The
+field-by-field mapping is documented at the top of `verdict.py`.
+
+## CLI
+
+```
+goldenreq list                          # the handler's inbox (pending requests)
+goldenreq accept <id> --by human:alice  # rule accept → fire the effect
+goldenreq reject <id> --by human:alice --reason "…"   # rule reject (reason required)
+```

goldenreq-0.3.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "goldenreq"
+version = "0.3.0"
+description = "The acceptance gate for goldenization: gauges FILE requests carrying receipts; a handler ACCEPTS/REJECTS; only an accept fires the promotion effect. Nothing self-promotes."
+requires-python = ">=3.11"
+# Deliberately dependency-free (stdlib only). The verdict record MIRRORS
+# base/acceptance's schema by shape, not by import (no cross-branch coupling).
+dependencies = []
+
+[project.scripts]
+goldenreq = "goldenreq.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

goldenreq-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

goldenreq-0.3.0/src/goldenreq/__init__.py

@@ -0,0 +1,30 @@
+"""goldenreq — the ACCEPTANCE GATE for goldenization.
+
+THE LAW (gauge ≠ handler). A *gauge* is an internal self-assessment: the
+bandit's 2×🏆 on a chain, a rulecatcher candidate, a forged template, a
+personapack grade claim. A gauge may detect quality but it may NEVER certify
+itself. Promotion to golden/adopted/canon happens only through a *handler* — an
+external acceptance authority. This package is that gate.
+
+  - `queue.file_request(...)` — a gauge FILES a request carrying its receipts
+    (evidence). That is the only move a gauge gets. The request sits pending.
+  - `verdict.accept / verdict.reject` — a handler rules. Only `accept` fires the
+    promotion effect (`effects.dispatch`). `reject` carries a reason.
+
+Requests carry receipts; verdicts are the seed corpus for the learned acceptance
+model that will one day staff this gate; rejections (with reasons) are its hard
+negatives. The verdict record mirrors base/acceptance's `Verdict` schema so the
+corpus is drop-in for that reader (field mapping: see `verdict.py`).
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .queue import KINDS, file_request, list_pending, get_request
+from .verdict import accept, reject, list_verdicts
+from . import effects
+
+__all__ = [
+    "KINDS", "file_request", "list_pending", "get_request",
+    "accept", "reject", "list_verdicts", "effects", "__version__",
+]

goldenreq-0.3.0/src/goldenreq/cli.py

@@ -0,0 +1,60 @@
+"""cli.py — `goldenreq list | accept | reject` (argparse, stdlib only)."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .queue import list_pending
+from .verdict import accept, reject
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="goldenreq",
+                                description="the acceptance gate for goldenization — nothing self-promotes")
+    p.add_argument("--queue", default=None, help="queue JSONL path ($GOLDENREQ_QUEUE_PATH)")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    lp = sub.add_parser("list", help="list pending requests (the handler's inbox)")
+    lp.add_argument("--json", action="store_true", help="emit raw JSON lines")
+
+    ap = sub.add_parser("accept", help="accept a request → fire its promotion effect")
+    ap.add_argument("request_id")
+    ap.add_argument("--by", required=True, help="ruling actor (human:<who> / model:<id>)")
+    ap.add_argument("--reason", default="")
+
+    rp = sub.add_parser("reject", help="reject a request (reason = hard negative)")
+    rp.add_argument("request_id")
+    rp.add_argument("--by", required=True, help="ruling actor (human:<who> / model:<id>)")
+    rp.add_argument("--reason", required=True)
+
+    args = p.parse_args(argv)
+
+    if args.cmd == "list":
+        pending = list_pending(args.queue)
+        if args.json:
+            for r in pending:
+                print(json.dumps(r, sort_keys=True))
+        elif not pending:
+            print("no pending requests")
+        else:
+            for r in pending:
+                print(f"{r['request_id']}  {r['kind']:<16}  {r['candidate_id']}  "
+                      f"→ {r['requested_promotion']}  (by {r['requester']}, "
+                      f"{len(r.get('evidence', []))} receipt(s))")
+        return 0
+
+    try:
+        if args.cmd == "accept":
+            v = accept(args.request_id, args.by, args.reason, queue_path=args.queue)
+        else:
+            v = reject(args.request_id, args.by, args.reason, queue_path=args.queue)
+    except (ValueError, FileNotFoundError, NotImplementedError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    print(json.dumps(v, sort_keys=True, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

goldenreq-0.3.0/src/goldenreq/effects.py

@@ -0,0 +1,105 @@
+"""effects.py — the promotion effects, dispatched ONLY on an accepted verdict.
+
+`dispatch` routes an accepted request to its effect by `kind`. An effect is the
+thing the gauge was NOT allowed to do itself; here it runs because a handler
+accepted. Each returns an `outcome` dict that verdict.py stores in the record.
+
+Honesty rule: two effects are real (they have a testable local target), two are
+stubs (they'd need cross-package wiring we cannot exercise here). The stubs
+raise `NotImplementedError` and point at the exact upstream call to make — we do
+NOT fake an integration we can't test.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+# the personapack activation_grade ladder, BEST → WORST.
+# Mirror of personapack.entry.GRADES (kept as a literal so goldenreq stays
+# dependency-free; a drift here is caught by the pack-grade-bump test).
+PACK_GRADES: tuple[str, ...] = ("tested-with-receipt", "proven-in-forge", "seed")
+
+
+def dispatch(request: dict, *, by: str, **kwargs) -> dict:
+    """Route an ACCEPTED request to its promotion effect. Returns the outcome dict."""
+    kind = request.get("kind")
+    if kind == "chain-golden":
+        return mark_chain_golden(request, by=by, **kwargs)
+    if kind == "pack-grade-bump":
+        new_grade = bump_pack_grade(request.get("requested_promotion") or _current_from(request))
+        return {"effect": "pack-grade-bump", "new_grade": new_grade,
+                "note": "pure result — personapack applies it to the PackEntry"}
+    if kind == "rule-adopt":
+        return adopt_rule(request, by=by, **kwargs)
+    if kind == "template-promote":
+        return promote_template(request, by=by, **kwargs)
+    raise ValueError(f"no effect for kind {request.get('kind')!r}")
+
+
+def _current_from(request: dict) -> str:
+    # if requested_promotion wasn't a grade, fall back to the weakest rung
+    return "seed"
+
+
+# ── chain-golden: append an ACCEPTED-BY marker into the GBA KB note ──────────
+def mark_chain_golden(request: dict, *, by: str, **_) -> dict:
+    """Write the golden marker into the GBA KB.
+
+    `candidate_id` is the path to the graded KB note (a `kb/<topic>.md`, headed
+    with a `glyphs:` grade line — see chainaios bandit.kb_instructions). We
+    APPEND an ACCEPTED-BY line; we NEVER rewrite the agent's own notes. The
+    marker is what turns "the gauge claims 🏆🏆" into "a handler certified it
+    golden" — the thing self-folding used to do without authority.
+    """
+    note = Path(request["candidate_id"])
+    if not note.exists():
+        raise FileNotFoundError(f"KB note not found: {note}")
+    marker = (f"\nACCEPTED-BY: {by} — goldenized on request {request['request_id']} "
+              f"(promotion: {request.get('requested_promotion')}); "
+              f"evidence: {', '.join(request.get('evidence', [])) or 'none'}. 🏆🏆 → golden\n")
+    with open(note, "a", encoding="utf-8") as f:
+        f.write(marker)
+    return {"effect": "chain-golden", "kb_note": str(note), "marker": marker.strip()}
+
+
+# ── pack-grade-bump: a PURE function personapack applies itself ──────────────
+def bump_pack_grade(current_grade: str) -> str:
+    """Return the next-higher personapack `activation_grade`, or the same grade
+    if already at the top. PURE — personapack constructs the new PackEntry with it.
+
+    Ladder (best→worst): tested-with-receipt > proven-in-forge > seed.
+    A bump moves ONE rung toward tested-with-receipt.
+    """
+    if current_grade not in PACK_GRADES:
+        raise ValueError(f"grade {current_grade!r} not in {PACK_GRADES}")
+    i = PACK_GRADES.index(current_grade)
+    return PACK_GRADES[max(0, i - 1)]
+
+
+# ── honest stubs: real cross-package integration we cannot test here ─────────
+def adopt_rule(request: dict, *, by: str, **_) -> dict:
+    """STUB. A real rule-adopt would call rulecatcher's adopt path:
+
+        rulecatcher.engine.adopt_rules(connection, rule_ids, actor=by,
+                                       source="goldenreq", reason=<verdict reason>)
+
+    (see packages/rulecatcher/src/rulecatcher/engine.py, `adopt_rules`).
+    That needs a live rulecatcher sqlite `Connection` and real candidate rule ids
+    threaded through the request — wiring goldenreq cannot construct or exercise
+    in isolation. Not faked.
+    """
+    raise NotImplementedError(
+        "rule-adopt: wire request.candidate_id (rule ids) + a rulecatcher "
+        "Connection to rulecatcher.engine.adopt_rules(actor=by, source='goldenreq'). "
+        "Deliberately unimplemented — no fake integration.")
+
+
+def promote_template(request: dict, *, by: str, **_) -> dict:
+    """STUB. A real template-promote would move a forged language/template from
+    candidate into the canonical set (the chainaios `construct_language` /
+    template store). That store's promotion API is not defined yet, so there is
+    nothing honest to call. Not faked.
+    """
+    raise NotImplementedError(
+        "template-promote: no canonical-template promotion API exists to call "
+        "yet; when one does, dispatch request.candidate_id to it here. "
+        "Deliberately unimplemented — no fake integration.")

goldenreq-0.3.0/src/goldenreq/queue.py

@@ -0,0 +1,132 @@
+"""queue.py — the goldenization request queue (append-only JSONL).
+
+Same append-only ledger idiom as the KB reward record and base/acceptance's
+verdict corpus (a `write` is one JSON line; nothing is ever mutated in place).
+
+A REQUEST is a *gauge-passed, handler-pending* event: a gauge — the bandit's
+2×🏆 on a constructed chain, a rulecatcher candidate rule, a forged
+language/template, a personapack `activation_grade` claim — asks for a
+promotion it may NOT grant itself. The request carries its RECEIPTS (evidence)
+and sits pending until a handler rules on it (see ``verdict.py``). This is
+JobWorld's ``supposedly_done`` made explicit, and base/acceptance's
+``handler.verdict == "escalate"`` (gauge-passed, handler-pending) as a queue.
+
+THE LAW: the gauge never certifies itself. Filing a request is the ONLY thing a
+gauge may do toward promotion; the promotion effect fires only on an accepted
+verdict.
+"""
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+# the four things that can be promoted (each has a real gauge upstream)
+KINDS: tuple[str, ...] = (
+    "chain-golden",      # a constructed bandit chain earned 🏆 twice (chainaios)
+    "rule-adopt",        # a rulecatcher candidate rule wants adoption
+    "template-promote",  # a forged language / template wants to become canon
+    "pack-grade-bump",   # a personapack PackEntry wants a higher activation_grade
+)
+
+QUEUE_ENV = "GOLDENREQ_QUEUE_PATH"
+VERDICTS_ENV = "GOLDENREQ_VERDICTS_PATH"
+DEFAULT_QUEUE = "goldenreq_queue.jsonl"
+DEFAULT_VERDICTS = "verdicts.jsonl"
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def resolve_queue_path(path: str | os.PathLike | None = None) -> Path:
+    return Path(path or os.environ.get(QUEUE_ENV) or DEFAULT_QUEUE)
+
+
+def resolve_verdicts_path(queue_path: str | os.PathLike | None = None) -> Path:
+    """The verdicts corpus sits beside the queue (or at $GOLDENREQ_VERDICTS_PATH).
+    Mirrors base/acceptance's `resolve_corpus_path` — env override, else default."""
+    env = os.environ.get(VERDICTS_ENV)
+    if env:
+        return Path(env)
+    return resolve_queue_path(queue_path).parent / DEFAULT_VERDICTS
+
+
+def _append(path: Path, record: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(record, sort_keys=True) + "\n")
+
+
+def _read_all(path: Path) -> list[dict]:
+    out: list[dict] = []
+    if not Path(path).exists():
+        return out
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                out.append(json.loads(line))
+            except Exception:
+                continue
+    return out
+
+
+def new_request_id() -> str:
+    return "gr-" + uuid.uuid4().hex[:24]
+
+
+def file_request(kind: str, candidate_id: str, evidence: list[str],
+                 requested_promotion: str, requester: str,
+                 queue_path: str | os.PathLike | None = None) -> str:
+    """Append one goldenization request to the queue. Returns its request_id.
+
+    `evidence` = the receipts (graded KB note paths, cert ids, forge reports).
+    A request with no evidence is still filed (honest — an unevidenced ask is a
+    weak ask a handler will likely reject), but evidence is what an acceptance
+    model later learns from, so gauges SHOULD attach it.
+    """
+    if kind not in KINDS:
+        raise ValueError(f"kind {kind!r} not in {KINDS}")
+    rid = new_request_id()
+    rec = {
+        "request_id": rid,
+        "ts": now_iso(),
+        "kind": kind,
+        "candidate_id": candidate_id,
+        "evidence": list(evidence or []),
+        "requested_promotion": requested_promotion,
+        "requester": requester,
+        "status": "pending",
+    }
+    _append(resolve_queue_path(queue_path), rec)
+    return rid
+
+
+def get_request(request_id: str, queue_path: str | os.PathLike | None = None) -> dict | None:
+    for rec in _read_all(resolve_queue_path(queue_path)):
+        if rec.get("request_id") == request_id:
+            return rec
+    return None
+
+
+def ruled_request_ids(queue_path: str | os.PathLike | None = None) -> set[str]:
+    """request_ids that already carry a handler verdict (accept OR reject)."""
+    vpath = resolve_verdicts_path(queue_path)
+    return {v.get("context_ref") for v in _read_all(vpath) if v.get("context_ref")}
+
+
+def list_pending(queue_path: str | os.PathLike | None = None) -> list[dict]:
+    """Requests with no handler verdict yet — the handler's inbox.
+
+    A request is pending ⇔ no verdict record points at it (verdict.context_ref
+    == request_id). That is base/acceptance's `escalate` state: gauge-passed,
+    handler-pending.
+    """
+    ruled = ruled_request_ids(queue_path)
+    return [r for r in _read_all(resolve_queue_path(queue_path))
+            if r.get("request_id") not in ruled]

goldenreq-0.3.0/src/goldenreq/verdict.py

@@ -0,0 +1,133 @@
+"""verdict.py — the HANDLER ruling on a goldenization request.
+
+`accept` / `reject` are the ONLY authority in this package. Nothing self-promotes:
+a promotion effect (effects.py) fires only when a handler `accept`s. A `reject`
+carries a reason — those reasons are the HARD NEGATIVES for the learned
+acceptance model that later staffs this gate.
+
+Verdict record shape — MIRRORS base/acceptance's `acceptance.schema.Verdict`
+(read via `git show acceptance-handler:base/acceptance/acceptance/schema.py`).
+We do NOT import across branches; we reproduce the shape as a plain dict so the
+verdicts corpus is drop-in compatible with that reader. Field mapping:
+
+    base/acceptance Verdict field   ← goldenreq source
+    ------------------------------    ----------------------------------------
+    id                              ← a fresh verdict id ("vd-…")
+    ts                              ← ruling timestamp (ISO-8601)
+    domain                          ← "goldenize"  (base lists this exact domain)
+    artifact_ref                    ← request.candidate_id (what was judged)
+    context_ref                     ← request.request_id   (the request it belongs to)
+    gauge.source                    ← request.requester    (the self-claiming gauge)
+    gauge.score                     ← request.requested_promotion (the gauge's claim)
+    gauge.reasons                   ← request.evidence     (the receipts it filed)
+    handler.verdict                 ← "accept" | "reject"  (base also has "escalate"
+                                       = still-pending; a pending request is exactly
+                                       that state, so it has NO verdict record yet)
+    handler.actor                   ← `by`, coerced to "human:<who>" / "model:<id>"
+    handler.reasons                 ← [reason]  (rejections MUST carry one)
+    handler.edits_made              ← None (goldenreq handlers rule, they don't edit)
+    outcome                         ← the promotion effect's result on accept, else None
+"""
+from __future__ import annotations
+
+import os
+import re
+import uuid
+
+from . import effects
+from .queue import (
+    get_request, now_iso, resolve_queue_path, resolve_verdicts_path,
+    ruled_request_ids, _append, _read_all,
+)
+
+ACTOR_PATTERN = re.compile(r"^(human|model):.+$")  # base/acceptance schema.ACTOR_PATTERN
+
+
+def new_verdict_id() -> str:
+    return "vd-" + uuid.uuid4().hex[:24]
+
+
+def _actor(by: str) -> str:
+    """Coerce `by` to the base schema's `^(human|model):.+$` actor form.
+    A bare name is assumed human (the default handler is a person doing QA)."""
+    by = (by or "").strip()
+    if not by:
+        raise ValueError("a verdict requires `by` (the ruling actor)")
+    return by if ACTOR_PATTERN.match(by) else f"human:{by}"
+
+
+def _build_verdict(request: dict, decision: str, by: str,
+                   reasons: list[str], outcome: dict | None) -> dict:
+    """One acceptance event, in base/acceptance Verdict shape (see module docstring)."""
+    return {
+        "id": new_verdict_id(),
+        "ts": now_iso(),
+        "domain": "goldenize",
+        "artifact_ref": request["candidate_id"],
+        "context_ref": request["request_id"],
+        "gauge": {
+            "source": request.get("requester", ""),
+            "score": request.get("requested_promotion"),
+            "reasons": list(request.get("evidence", [])),
+        },
+        "handler": {
+            "verdict": decision,
+            "actor": _actor(by),
+            "reasons": list(reasons),
+            "edits_made": None,
+        },
+        "outcome": outcome,
+    }
+
+
+def _guard(request_id: str, queue_path) -> dict:
+    request = get_request(request_id, queue_path=queue_path)
+    if request is None:
+        raise ValueError(f"no such request: {request_id}")
+    if request_id in ruled_request_ids(queue_path):
+        raise ValueError(f"request {request_id} already has a verdict (no double-ruling)")
+    return request
+
+
+def accept(request_id: str, by: str, reason: str = "", *,
+           queue_path: str | os.PathLike | None = None,
+           verdicts_path: str | os.PathLike | None = None,
+           effect_kwargs: dict | None = None) -> dict:
+    """ACCEPT a request → fire its promotion effect, then record the verdict.
+
+    The effect runs BEFORE the record is written so its result is captured in
+    `outcome` (the audit trail). If the effect raises, nothing is recorded and
+    the request stays pending — no half-promotion. Returns the verdict record.
+    """
+    from pathlib import Path
+    request = _guard(request_id, queue_path)
+    outcome = effects.dispatch(request, by=_actor(by), **(effect_kwargs or {}))
+    verdict = _build_verdict(request, "accept", by, [reason] if reason else [], outcome)
+    vpath = Path(verdicts_path) if verdicts_path is not None else resolve_verdicts_path(queue_path)
+    _append(vpath, verdict)
+    return verdict
+
+
+def reject(request_id: str, by: str, reason: str, *,
+           queue_path: str | os.PathLike | None = None,
+           verdicts_path: str | os.PathLike | None = None) -> dict:
+    """REJECT a request → NO effect, record the verdict with its reason.
+
+    The reason is mandatory: rejections are the hard negatives the learned
+    acceptance model trains on. Nothing is promoted.
+    """
+    if not (reason or "").strip():
+        raise ValueError("reject requires a reason (it is the hard negative)")
+    request = _guard(request_id, queue_path)
+    verdict = _build_verdict(request, "reject", by, [reason], None)
+    from pathlib import Path
+    vpath = Path(verdicts_path) if verdicts_path is not None else resolve_verdicts_path(queue_path)
+    _append(vpath, verdict)
+    return verdict
+
+
+def list_verdicts(queue_path: str | os.PathLike | None = None,
+                  verdicts_path: str | os.PathLike | None = None) -> list[dict]:
+    from pathlib import Path
+    vpath = Path(verdicts_path) if verdicts_path is not None else resolve_verdicts_path(queue_path)
+    return _read_all(vpath)

goldenreq-0.3.0/src/goldenreq.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: goldenreq
+Version: 0.3.0
+Summary: The acceptance gate for goldenization: gauges FILE requests carrying receipts; a handler ACCEPTS/REJECTS; only an accept fires the promotion effect. Nothing self-promotes.
+Requires-Python: >=3.11

goldenreq-0.3.0/src/goldenreq.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/goldenreq/__init__.py
+src/goldenreq/cli.py
+src/goldenreq/effects.py
+src/goldenreq/queue.py
+src/goldenreq/verdict.py
+src/goldenreq.egg-info/PKG-INFO
+src/goldenreq.egg-info/SOURCES.txt
+src/goldenreq.egg-info/dependency_links.txt
+src/goldenreq.egg-info/entry_points.txt
+src/goldenreq.egg-info/top_level.txt
+tests/test_goldenreq.py

goldenreq-0.3.0/src/goldenreq.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

goldenreq-0.3.0/src/goldenreq.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+goldenreq = goldenreq.cli:main

goldenreq-0.3.0/src/goldenreq.egg-info/top_level.txt

@@ -0,0 +1 @@
+goldenreq

goldenreq-0.3.0/tests/test_goldenreq.py

@@ -0,0 +1,166 @@
+"""goldenreq — the acceptance gate. Nothing self-promotes; only an accepted
+verdict fires an effect; the verdict record mirrors base/acceptance's schema."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+import goldenreq
+from goldenreq import effects
+from goldenreq.queue import resolve_verdicts_path
+
+
+def _q(tmp_path) -> Path:
+    return tmp_path / "goldenreq_queue.jsonl"
+
+
+# ── file → list → accept → effect (chain-golden marker lands in a GBA KB) ────
+def test_file_list_accept_chain_golden_marker_lands(tmp_path):
+    q = _q(tmp_path)
+    # a real GBA KB note, headed with a glyphs grade line (chainaios kb_instructions shape)
+    kb = tmp_path / "kb"; kb.mkdir()
+    note = kb / "rollback-chain.md"
+    original = "glyphs: 🏆🏆\n\n# rollback chain\n\nConstructed chain that earned 🏆 twice.\n"
+    note.write_text(original)
+
+    rid = goldenreq.file_request(
+        "chain-golden", str(note),
+        evidence=[str(note), "round-7 reward log"],
+        requested_promotion="golden", requester="triage-bandit", queue_path=q)
+    assert rid.startswith("gr-")
+
+    pending = goldenreq.list_pending(q)
+    assert len(pending) == 1 and pending[0]["request_id"] == rid
+    assert pending[0]["status"] == "pending"
+
+    verdict = goldenreq.accept(rid, "human:alice", "chain proved out twice", queue_path=q)
+
+    # the promotion effect actually ran: marker APPENDED, original NOT rewritten
+    body = note.read_text()
+    assert body.startswith(original)                     # agent's note untouched
+    assert "ACCEPTED-BY: human:alice" in body
+    assert "🏆🏆 → golden" in body
+    assert verdict["handler"]["verdict"] == "accept"
+    assert verdict["outcome"]["effect"] == "chain-golden"
+
+    # once ruled, it leaves the pending inbox
+    assert goldenreq.list_pending(q) == []
+
+
+# ── reject → no effect + reason recorded as a hard negative ──────────────────
+def test_reject_records_reason_and_fires_no_effect(tmp_path):
+    q = _q(tmp_path)
+    kb = tmp_path / "kb"; kb.mkdir()
+    note = kb / "flaky-chain.md"
+    original = "glyphs: 🏆\n\n# flaky chain\n"
+    note.write_text(original)
+
+    rid = goldenreq.file_request("chain-golden", str(note), evidence=[str(note)],
+                                 requested_promotion="golden", requester="triage-bandit",
+                                 queue_path=q)
+    verdict = goldenreq.reject(rid, "human:alice", "only one 🏆, evidence thin", queue_path=q)
+
+    assert verdict["handler"]["verdict"] == "reject"
+    assert verdict["handler"]["reasons"] == ["only one 🏆, evidence thin"]
+    assert verdict["outcome"] is None
+    assert note.read_text() == original                  # NO effect ran
+    assert goldenreq.list_pending(q) == []               # ruled → out of inbox
+
+
+def test_reject_requires_a_reason(tmp_path):
+    q = _q(tmp_path)
+    rid = goldenreq.file_request("chain-golden", "/x", evidence=[], requested_promotion="golden",
+                                 requester="b", queue_path=q)
+    with pytest.raises(ValueError):
+        goldenreq.reject(rid, "human:alice", "", queue_path=q)
+
+
+def test_no_double_ruling(tmp_path):
+    q = _q(tmp_path)
+    note = tmp_path / "n.md"; note.write_text("glyphs: 🏆🏆\n")
+    rid = goldenreq.file_request("chain-golden", str(note), evidence=[], requested_promotion="golden",
+                                 requester="b", queue_path=q)
+    goldenreq.accept(rid, "human:alice", queue_path=q)
+    with pytest.raises(ValueError):
+        goldenreq.reject(rid, "human:alice", "changed my mind", queue_path=q)
+
+
+# ── verdict records match the documented base/acceptance field mapping ───────
+def test_verdict_record_mirrors_base_acceptance_schema(tmp_path):
+    q = _q(tmp_path)
+    note = tmp_path / "n.md"; note.write_text("glyphs: 🏆🏆\n")
+    rid = goldenreq.file_request(
+        "chain-golden", str(note), evidence=["ev-a", "ev-b"],
+        requested_promotion="golden", requester="triage-bandit", queue_path=q)
+    v = goldenreq.accept(rid, "alice", "ok", queue_path=q)  # bare name → coerced to human:
+
+    # the exact keys base/acceptance.schema.Verdict defines
+    assert set(v) == {"id", "ts", "domain", "artifact_ref", "context_ref",
+                      "gauge", "handler", "outcome"}
+    assert v["id"].startswith("vd-")
+    assert v["domain"] == "goldenize"                       # base lists this domain
+    assert v["artifact_ref"] == str(note)                   # ← request.candidate_id
+    assert v["context_ref"] == rid                          # ← request.request_id
+    # gauge = the internal claim (never authority)
+    assert set(v["gauge"]) == {"source", "score", "reasons"}
+    assert v["gauge"]["source"] == "triage-bandit"          # ← request.requester
+    assert v["gauge"]["score"] == "golden"                  # ← request.requested_promotion
+    assert v["gauge"]["reasons"] == ["ev-a", "ev-b"]        # ← request.evidence
+    # handler = the external authority; actor matches base's ^(human|model):.+$
+    assert set(v["handler"]) == {"verdict", "actor", "reasons", "edits_made"}
+    assert v["handler"]["actor"] == "human:alice"
+    assert v["handler"]["verdict"] in {"accept", "reject"}
+    assert v["handler"]["edits_made"] is None
+
+    # it round-trips as a JSONL corpus line (drop-in for the base reader)
+    vpath = resolve_verdicts_path(q)
+    line = vpath.read_text().splitlines()[-1]
+    assert json.loads(line)["id"] == v["id"]
+
+
+# ── pack-grade-bump is a pure ladder step ────────────────────────────────────
+def test_bump_pack_grade_is_pure_and_matches_personapack_ladder():
+    # ladder best→worst: tested-with-receipt > proven-in-forge > seed
+    assert effects.bump_pack_grade("seed") == "proven-in-forge"
+    assert effects.bump_pack_grade("proven-in-forge") == "tested-with-receipt"
+    assert effects.bump_pack_grade("tested-with-receipt") == "tested-with-receipt"  # capped at top
+    with pytest.raises(ValueError):
+        effects.bump_pack_grade("made-up")
+    # drift guard: our literal ladder equals personapack's GRADES
+    from personapack.entry import GRADES
+    assert effects.PACK_GRADES == GRADES
+
+
+def test_pack_grade_bump_via_accept(tmp_path):
+    q = _q(tmp_path)
+    rid = goldenreq.file_request("pack-grade-bump", "some-persona", evidence=["gba-receipt"],
+                                 requested_promotion="proven-in-forge", requester="personapack",
+                                 queue_path=q)
+    v = goldenreq.accept(rid, "human:alice", queue_path=q)
+    assert v["outcome"]["effect"] == "pack-grade-bump"
+    assert v["outcome"]["new_grade"] == "tested-with-receipt"
+
+
+# ── the honest stubs raise NotImplementedError (no fake integration) ─────────
+def test_rule_adopt_and_template_promote_are_honest_stubs(tmp_path):
+    q = _q(tmp_path)
+    for kind in ("rule-adopt", "template-promote"):
+        rid = goldenreq.file_request(kind, "cand", evidence=[], requested_promotion="adopt",
+                                     requester="g", queue_path=q)
+        with pytest.raises(NotImplementedError):
+            goldenreq.accept(rid, "human:alice", queue_path=q)
+        # the failed effect left the request PENDING (no half-promotion, no verdict)
+        assert any(r["request_id"] == rid for r in goldenreq.list_pending(q))
+
+
+# ── the chainaios bandit.py rule text no longer self-promotes (grep test) ────
+def test_bandit_rule_text_files_a_request_not_self_fold():
+    bandit = (Path(__file__).resolve().parents[2] / "chainaios" / "src" / "chainaios" / "bandit.py")
+    text = bandit.read_text()
+    assert "FILE A GOLDENIZATION REQUEST" in text
+    assert "never self-fold to golden" in text
+    assert "promotion" in text and "accepted verdict" in text
+    # the old self-certifying instruction is gone
+    assert "fold it into a golden chain" not in text