abom-cli 0.1.0__py3-none-any.whl

abom/__init__.py

@@ -0,0 +1,3 @@
+"""ABOM — production control plane for agentic AI (Step-1 MVP scaffold)."""
+
+__version__ = "0.1.0"

abom/agents.py

@@ -0,0 +1,58 @@
+"""Agent harness adapter + a minimal reference implementation.
+
+`AgentHarness` is the swappable seam described in the architecture: the MVP ships
+`SimpleAgent`, but a wrapped open framework (LangGraph, etc.) can implement the
+same interface without changing the workflow.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from .models_router import Router
+
+
+@dataclass
+class Proposal:
+    patch_text: str
+    rationale: str
+    prompt_tokens: int
+    completion_tokens: int
+
+
+SYSTEM_PROMPT = (
+    "You are a software engineering agent operating inside a regulated boundary. "
+    "Given a task and (on retries) the failing test output, return a single unified "
+    "diff that makes the test suite pass. Output only the patch."
+)
+
+
+class AgentHarness(Protocol):
+    async def propose(self, *, intent: str, iteration: int, feedback: dict | None) -> Proposal:
+        ...
+
+
+class SimpleAgent:
+    """Thin single-model loop. The reliability runtime (gate + critic) lives in
+    the workflow, not here — that separation is the point."""
+
+    def __init__(self, router: Router):
+        self.router = router
+        self.client = router.client()
+        self._history: list[dict[str, str]] = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+    async def propose(self, *, intent: str, iteration: int, feedback: dict | None) -> Proposal:
+        if iteration == 0:
+            self._history.append({"role": "user", "content": f"Task: {intent}"})
+        else:
+            self._history.append(
+                {"role": "user", "content": f"The gate failed. Output:\n{feedback}\nFix it."}
+            )
+        resp = await self.client.complete(self._history)
+        self._history.append({"role": "assistant", "content": resp.text})
+        return Proposal(
+            patch_text=resp.text,
+            rationale=f"iteration {iteration}",
+            prompt_tokens=resp.prompt_tokens,
+            completion_tokens=resp.completion_tokens,
+        )

abom/api.py

@@ -0,0 +1,177 @@
+"""Control API: FastAPI app, auth dependency, and routes (MVP_SPEC §7)."""
+from __future__ import annotations
+
+import uuid
+from typing import Annotated
+
+from fastapi import Depends, FastAPI, Header, HTTPException, Query
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from .config import settings
+from .db import (
+    AuditEvent, Project, Run, RunStep, get_session,
+)
+from .schemas import (
+    ApprovalDecision, AuditEventOut, ProjectCreate, ProjectOut, RunCreate,
+    RunOut, StepOut, VerifyResult,
+)
+from . import audit
+
+app = FastAPI(title="ABOM Control API", version="0.1.0")
+
+Session = Annotated[AsyncSession, Depends(get_session)]
+
+
+# --------------------------------- auth -------------------------------------
+class Principal:
+    def __init__(self, subject: str, roles: list[str]):
+        self.subject = subject
+        self.roles = roles
+
+
+async def current_principal(authorization: str = Header(default="")) -> Principal:
+    """Validate the bearer token.
+
+    Dev mode (no OIDC_JWKS_URL): accept the static token and grant all roles.
+    Phase-2: verify JWT signature against JWKS and map the `roles` claim.
+    """
+    token = authorization.removeprefix("Bearer ").strip()
+    if not token:
+        raise HTTPException(401, "missing bearer token")
+    if not settings.oidc_jwks_url:  # dev mode
+        if token != settings.dev_static_token:
+            raise HTTPException(401, "invalid dev token")
+        return Principal("dev@local", ["developer", "operator", "auditor"])
+    # TODO: real JWKS validation
+    raise HTTPException(501, "OIDC validation not implemented in MVP scaffold")
+
+
+def require(role: str):
+    async def dep(principal: Principal = Depends(current_principal)) -> Principal:
+        if role not in principal.roles:
+            raise HTTPException(403, f"role '{role}' required")
+        return principal
+    return dep
+
+
+# --------------------------------- health -----------------------------------
+@app.get("/healthz")
+async def healthz():
+    return {"status": "ok"}
+
+
+@app.get("/readyz")
+async def readyz(session: Session):
+    await session.execute(select(1))
+    return {"status": "ready"}
+
+
+# -------------------------------- projects ----------------------------------
+@app.post("/v1/projects", response_model=ProjectOut, status_code=201)
+async def create_project(body: ProjectCreate, session: Session,
+                         _: Principal = Depends(require("operator"))):
+    proj = Project(name=body.name, repo_url=body.repo_url, test_command=body.test_command)
+    session.add(proj)
+    await session.commit()
+    await session.refresh(proj)
+    return proj
+
+
+# ---------------------------------- runs ------------------------------------
+@app.post("/v1/runs", response_model=RunOut, status_code=201)
+async def create_run(body: RunCreate, session: Session,
+                     principal: Principal = Depends(require("developer"))):
+    if not (await session.execute(select(Project).where(Project.id == body.project_id))).scalar_one_or_none():
+        raise HTTPException(404, "project not found")
+    run = Run(project_id=body.project_id, created_by=principal.subject, intent=body.intent,
+              workload_type=body.workload_type, max_iterations=body.max_iterations, status="pending")
+    session.add(run)
+    await session.commit()
+    await session.refresh(run)
+    await _start_workflow(str(run.id), body.max_iterations)
+    return run
+
+
+@app.get("/v1/runs/{run_id}", response_model=RunOut)
+async def get_run(run_id: uuid.UUID, session: Session,
+                  _: Principal = Depends(require("developer"))):
+    run = (await session.execute(select(Run).where(Run.id == run_id))).scalar_one_or_none()
+    if not run:
+        raise HTTPException(404, "run not found")
+    return run
+
+
+@app.get("/v1/runs/{run_id}/steps", response_model=list[StepOut])
+async def get_steps(run_id: uuid.UUID, session: Session,
+                    _: Principal = Depends(require("developer"))):
+    rows = (await session.execute(
+        select(RunStep).where(RunStep.run_id == run_id).order_by(RunStep.seq)
+    )).scalars().all()
+    return rows
+
+
+@app.post("/v1/runs/{run_id}/approve")
+async def approve_run(run_id: uuid.UUID, body: ApprovalDecision,
+                      principal: Principal = Depends(require("operator"))):
+    await _signal_workflow(str(run_id), body.decision, principal.subject)
+    return {"run_id": str(run_id), "decision": body.decision}
+
+
+@app.post("/v1/runs/{run_id}/cancel")
+async def cancel_run(run_id: uuid.UUID, _: Principal = Depends(require("operator"))):
+    await _cancel_workflow(str(run_id))
+    return {"run_id": str(run_id), "status": "cancelling"}
+
+
+# ---------------------------------- audit -----------------------------------
+@app.get("/v1/audit", response_model=list[AuditEventOut])
+async def get_audit(session: Session, run_id: uuid.UUID = Query(...),
+                    _: Principal = Depends(require("auditor"))):
+    rows = (await session.execute(
+        select(AuditEvent).where(AuditEvent.run_id == run_id).order_by(AuditEvent.seq)
+    )).scalars().all()
+    return rows
+
+
+@app.get("/v1/audit/verify", response_model=VerifyResult)
+async def verify_audit(session: Session, run_id: uuid.UUID = Query(...),
+                       _: Principal = Depends(require("auditor"))):
+    rows = (await session.execute(
+        select(AuditEvent).where(AuditEvent.run_id == run_id).order_by(AuditEvent.seq)
+    )).scalars().all()
+    events = [
+        {"run_id": str(r.run_id), "seq": r.seq, "event_type": r.event_type, "actor": r.actor,
+         "data": r.data, "created_at": r.created_at.isoformat(),
+         "prev_hash": r.prev_hash, "hash": r.hash}
+        for r in rows
+    ]
+    result = audit.verify_chain(events)
+    return VerifyResult(run_id=run_id, event_count=len(events), **result)
+
+
+# ------------------------ Temporal client helpers ---------------------------
+async def _client():
+    from temporalio.client import Client
+    return await Client.connect(settings.temporal_host, namespace=settings.temporal_namespace)
+
+
+async def _start_workflow(run_id: str, max_iterations: int):
+    from .orchestration import AgentRunWorkflow
+    client = await _client()
+    await client.start_workflow(
+        AgentRunWorkflow.run, args=[run_id, max_iterations],
+        id=f"run-{run_id}", task_queue=settings.task_queue,
+    )
+
+
+async def _signal_workflow(run_id: str, decision: str, approver: str):
+    from .orchestration import AgentRunWorkflow
+    client = await _client()
+    handle = client.get_workflow_handle(f"run-{run_id}")
+    await handle.signal(AgentRunWorkflow.approve, args=[decision, approver])
+
+
+async def _cancel_workflow(run_id: str):
+    client = await _client()
+    await client.get_workflow_handle(f"run-{run_id}").cancel()

abom/audit.py

@@ -0,0 +1,122 @@
+"""Tamper-evident audit log.
+
+The hashing functions at the top are PURE (stdlib only) so they can be unit
+tested without a database — see tests/test_audit_chain.py. Persistence helpers
+at the bottom take an async DB session.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Iterable
+
+GENESIS = "GENESIS"
+
+
+def canonical_json(obj: Any) -> str:
+    """Deterministic JSON encoding used for hashing."""
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"), default=str)
+
+
+def compute_hash(
+    *, run_id: str, seq: int, event_type: str, actor: str, data: Any,
+    prev_hash: str, created_at: str,
+) -> str:
+    payload = {
+        "run_id": str(run_id),
+        "seq": seq,
+        "event_type": event_type,
+        "actor": actor,
+        "data": data,
+        "prev_hash": prev_hash,
+        "created_at": created_at,
+    }
+    return hashlib.sha256(canonical_json(payload).encode("utf-8")).hexdigest()
+
+
+@dataclass
+class AuditRecord:
+    run_id: str
+    seq: int
+    event_type: str
+    actor: str
+    data: Any
+    created_at: str
+    prev_hash: str
+    hash: str
+
+
+def make_record(
+    *, run_id: str, seq: int, event_type: str, actor: str, data: Any,
+    prev_hash: str, created_at: str | None = None,
+) -> AuditRecord:
+    created_at = created_at or datetime.now(timezone.utc).isoformat()
+    h = compute_hash(
+        run_id=run_id, seq=seq, event_type=event_type, actor=actor,
+        data=data, prev_hash=prev_hash, created_at=created_at,
+    )
+    return AuditRecord(run_id, seq, event_type, actor, data, created_at, prev_hash, h)
+
+
+def verify_chain(events: Iterable[dict]) -> dict:
+    """Recompute the chain. Returns {"valid": bool, "broken_seq": int|None, "reason": str|None}.
+
+    `events` must be ordered by seq ascending. Each dict needs:
+    run_id, seq, event_type, actor, data, created_at, prev_hash, hash.
+    """
+    expected_prev = GENESIS
+    last_seq = None
+    for e in events:
+        if last_seq is not None and e["seq"] != last_seq + 1:
+            return {"valid": False, "broken_seq": e["seq"], "reason": "non-contiguous seq"}
+        if e["prev_hash"] != expected_prev:
+            return {"valid": False, "broken_seq": e["seq"], "reason": "prev_hash mismatch"}
+        recomputed = compute_hash(
+            run_id=e["run_id"], seq=e["seq"], event_type=e["event_type"],
+            actor=e["actor"], data=e["data"], prev_hash=e["prev_hash"],
+            created_at=e["created_at"],
+        )
+        if recomputed != e["hash"]:
+            return {"valid": False, "broken_seq": e["seq"], "reason": "hash mismatch"}
+        expected_prev = e["hash"]
+        last_seq = e["seq"]
+    return {"valid": True, "broken_seq": None, "reason": None}
+
+
+# --------------------------------------------------------------------------
+# Persistence (requires DB session). Imported lazily to keep hashing pure.
+# --------------------------------------------------------------------------
+async def append_event(session, *, run_id: str, event_type: str, actor: str, data: Any) -> AuditRecord:
+    """Append one event to a run's chain inside an existing transaction.
+
+    Locks the run's events to compute the next seq + prev_hash atomically.
+    """
+    from sqlalchemy import select, func
+    from .db import AuditEvent
+
+    row = (
+        await session.execute(
+            select(AuditEvent)
+            .where(AuditEvent.run_id == run_id)
+            .order_by(AuditEvent.seq.desc())
+            .limit(1)
+            .with_for_update()
+        )
+    ).scalar_one_or_none()
+
+    seq = (row.seq + 1) if row else 0
+    prev_hash = row.hash if row else GENESIS
+    rec = make_record(
+        run_id=str(run_id), seq=seq, event_type=event_type, actor=actor,
+        data=data, prev_hash=prev_hash,
+    )
+    session.add(
+        AuditEvent(
+            run_id=run_id, seq=rec.seq, event_type=rec.event_type, actor=rec.actor,
+            data=rec.data, prev_hash=rec.prev_hash, hash=rec.hash,
+            created_at=datetime.fromisoformat(rec.created_at),
+        )
+    )
+    return rec

abom/bom.py

@@ -0,0 +1,147 @@
+"""ABOM core — Composition Manifest, Action Provenance, and abom-verify.
+
+Pure stdlib + abom.audit for the tamper-evident chain. Two artifacts plus a
+policy verifier:
+
+  * build_composition(...)  -> signed Composition Manifest (what the agent IS)
+  * append_action(...)      -> hash-chained Action Provenance (what the agent DID)
+  * verify_abom(...)        -> abom-verify: policy findings over an ABOM
+
+The signature here is an HMAC stand-in, clearly labelled. Production uses
+detached ed25519 / cosign with keys in Vault/KMS — see ARCHITECTURE.md §3.6.
+"""
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+
+from . import sign as _sign
+from .audit import GENESIS, canonical_json, make_record, verify_chain
+
+ABOM_VERSION = "0.1"
+
+
+def _sha256(obj) -> str:
+    return hashlib.sha256(canonical_json(obj).encode("utf-8")).hexdigest()
+
+
+def sign(obj: dict, key=None) -> dict:
+    """Sign an ABOM object with a detached ed25519 signature."""
+    return _sign.sign_obj(obj, key)
+
+
+def verify_signature(obj: dict, trusted_keys=None) -> bool:
+    return _sign.verify_obj(obj, trusted_keys)
+
+
+# --- Composition Manifest (what the agent IS) --------------------------------
+def build_composition(agent: dict, components: list[dict], controls: dict,
+                      *, sign: bool = True, key=None) -> dict:
+    """Build a Composition Manifest (extends CycloneDX ML-BOM), ed25519-signed by default."""
+    body = {
+        "abom": ABOM_VERSION, "extends": "CycloneDX ML-BOM",
+        "type": "CompositionManifest",
+        "agent": agent, "components": components, "controls": controls,
+    }
+    body["composition_sha256"] = _sha256(body)
+    return _sign.sign_obj(body, key) if sign else body
+
+
+# --- Action Provenance (what the agent DID) ----------------------------------
+def new_chain() -> list:
+    return []
+
+
+def append_action(chain: list, *, composition_sha256: str, agent_ref: str, decision: str,
+                  inputs=None, model_calls=None, tools_invoked=None, data_touched=None,
+                  policy_decisions=None, approval=None) -> dict:
+    """Append one hash-chained Action Provenance Record to the chain."""
+    data = {
+        "composition_sha256": composition_sha256,
+        "decision": decision,
+        "inputs": inputs or [],
+        "model_calls": model_calls or [],
+        "tools_invoked": tools_invoked or [],
+        "data_touched": data_touched or [],
+        "policy_decisions": policy_decisions or [],
+        "approval": approval,
+    }
+    prev = chain[-1]["hash"] if chain else GENESIS
+    rec = make_record(run_id=agent_ref, seq=len(chain), event_type="ActionProvenance",
+                      actor="abom-gen", data=data, prev_hash=prev)
+    row = dataclasses.asdict(rec)
+    chain.append(row)
+    return row
+
+
+# --- abom-verify (policy findings over an ABOM) ------------------------------
+DEFAULT_POLICY = {
+    "allowed_models": ["local/qwen2.5-coder"],
+    "allowed_egress_endpoints": ["internal-kyc.bank"],
+    "no_egress_classifications": ["confidential", "restricted"],
+    "require_approval_when": "consequential",
+}
+
+
+def verify_abom(composition: dict, chain: list | None = None, policy: dict | None = None) -> dict:
+    """Verify a Composition Manifest (+ optional Action Provenance chain) against policy.
+
+    With no policy, checks structural integrity only (signature + chain). With a
+    policy, also enforces the model allowlist, residency, egress allowlist, and
+    approval coverage. Returns {"ok", "findings", "actions", "components"}.
+    """
+    policy = policy or {}
+    chain = chain or []
+    findings: list[dict] = []
+    comp_hash = composition.get("composition_sha256")
+    declared_models = {c.get("name") for c in composition.get("components", [])
+                       if c.get("type") == "model"}
+    allowed_models = policy.get("allowed_models")
+    no_egress = set(policy.get("no_egress_classifications", []))
+    allowed_eps = policy.get("allowed_egress_endpoints")
+
+    if not verify_signature(composition):
+        findings.append({"rule": "signature", "severity": "high",
+                         "detail": "composition signature invalid or missing"})
+    cv = verify_chain(chain)
+    if not cv["valid"]:
+        findings.append({"rule": "chain_integrity", "severity": "high",
+                         "detail": f"provenance broken at seq {cv['broken_seq']} ({cv['reason']})"})
+
+    # composition-level: declared models must be on the allowlist (when one is set)
+    if allowed_models is not None:
+        for nm in sorted(m for m in declared_models if m):
+            if nm not in allowed_models:
+                findings.append({"rule": "model_allowlist", "component": nm, "severity": "medium",
+                                 "detail": f"declared model not on allowlist: {nm}"})
+
+    for ev in chain:
+        d, seq = ev["data"], ev["seq"]
+        if comp_hash and d.get("composition_sha256") != comp_hash:
+            findings.append({"rule": "composition_match", "seq": seq, "severity": "high",
+                             "detail": "action references a different composition"})
+        for mc in d.get("model_calls", []):
+            m = mc.get("model")
+            if allowed_models is not None and m not in allowed_models:
+                findings.append({"rule": "model_allowlist", "seq": seq, "severity": "high",
+                                 "detail": f"unapproved model used: {m}"})
+            if m not in declared_models:
+                findings.append({"rule": "composition_drift", "seq": seq, "severity": "high",
+                                 "detail": f"runtime model not in signed manifest: {m}"})
+        for dt in d.get("data_touched", []):
+            if dt.get("egress") and dt.get("classification") in no_egress:
+                findings.append({"rule": "residency", "seq": seq, "severity": "high",
+                                 "detail": f"{dt.get('classification')} data egressed"})
+        for ti in d.get("tools_invoked", []):
+            ep = ti.get("endpoint")
+            if ep and allowed_eps is not None and ep not in allowed_eps:
+                findings.append({"rule": "egress_allowlist", "seq": seq, "severity": "medium",
+                                 "detail": f"egress to unapproved endpoint: {ep}"})
+        if any(pd.get("result") == "required" for pd in d.get("policy_decisions", [])):
+            ap = d.get("approval")
+            if not (ap and ap.get("decision") == "approved"):
+                findings.append({"rule": "approval_coverage", "seq": seq, "severity": "high",
+                                 "detail": "consequential action without approval"})
+
+    return {"ok": len(findings) == 0, "findings": findings,
+            "actions": len(chain), "components": len(composition.get("components", []))}

abom/cli.py

@@ -0,0 +1,130 @@
+"""abom — the Agent Bill of Materials CLI.
+
+    abom scan .                 # detect components, emit a signed ABOM
+    abom verify abom.json       # check signature (and policy, if given)
+    abom keygen                 # show the local ed25519 signing key
+    abom version
+
+Exit code is non-zero when verification finds violations, so it drops into CI.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from . import __version__, bom, scan as scanner, sign
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    help="ABOM — know what your AI agents are made of, and prove it.",
+)
+
+TYPE_LABEL = {
+    "model": "models", "tool": "tools", "prompt": "prompts", "dataSource": "data sources",
+    "policy": "policies / guardrails", "framework": "frameworks", "mcpServer": "MCP servers",
+}
+
+
+@app.command()
+def scan(
+    path: str = typer.Argument(".", help="Repository or directory to scan."),
+    output: str = typer.Option("abom.json", "-o", "--output", help="Output file ('-' for stdout)."),
+    sign_manifest: bool = typer.Option(True, "--sign/--no-sign", help="ed25519-sign the manifest."),
+    name: str = typer.Option(None, "--name", help="Override the detected agent name."),
+    version: str = typer.Option(None, "--agent-version", help="Override the detected agent version."),
+):
+    """Scan a repo and emit a signed ABOM Composition Manifest."""
+    root = Path(path)
+    if not root.exists():
+        typer.secho(f"path not found: {path}", fg="red", err=True)
+        raise typer.Exit(2)
+
+    result = scanner.scan(root)
+    if name:
+        result["agent"]["name"] = name
+    if version:
+        result["agent"]["version"] = version
+    manifest = bom.build_composition(
+        result["agent"], result["components"], result["controls"], sign=sign_manifest
+    )
+
+    text = json.dumps(manifest, indent=2)
+    if output == "-":
+        typer.echo(text)
+    else:
+        Path(output).write_text(text)
+
+    a = manifest["agent"]
+    typer.secho(f"\n  ABOM · {a['name']} @ {a['version']}", fg="cyan", bold=True)
+    by_type: dict[str, list] = {}
+    for c in manifest["components"]:
+        by_type.setdefault(c["type"], []).append(c.get("name", "?"))
+    if not by_type:
+        typer.secho("  no agent components detected (is this an agent repo?)", fg="yellow")
+    for t, names in by_type.items():
+        typer.echo(f"  {TYPE_LABEL.get(t, t):22} {len(names):>2}  " + ", ".join(names[:6])
+                   + (" …" if len(names) > 6 else ""))
+    sig = manifest.get("signature", {})
+    if sig:
+        typer.secho(f"  signed: {sig.get('alg')} · key {sig.get('key_id', '?')}", fg="green")
+    typer.echo(f"  composition_sha256: {manifest['composition_sha256'][:16]}…")
+    if output != "-":
+        typer.secho(f"  → wrote {output}\n", fg="cyan")
+
+
+@app.command()
+def verify(
+    abom_file: str = typer.Argument("abom.json", help="ABOM file to verify."),
+    policy_file: str = typer.Option(None, "--policy", "-p", help="Policy JSON to enforce."),
+):
+    """Verify an ABOM's signature, and (with --policy) its compliance."""
+    try:
+        doc = json.loads(Path(abom_file).read_text())
+    except Exception as exc:
+        typer.secho(f"could not read {abom_file}: {exc}", fg="red", err=True)
+        raise typer.Exit(2)
+    if doc.get("type") != "CompositionManifest":
+        typer.secho("not a Composition Manifest (verify expects `abom scan` output)", fg="red", err=True)
+        raise typer.Exit(2)
+
+    policy = json.loads(Path(policy_file).read_text()) if policy_file else None
+    result = bom.verify_abom(doc, [], policy)
+
+    if result["ok"]:
+        typer.secho(f"\n  ✓ VALID — signature OK, {result['components']} components"
+                    + (", policy clean" if policy else "") + "\n", fg="green", bold=True)
+        raise typer.Exit(0)
+
+    typer.secho(f"\n  ✗ {len(result['findings'])} finding(s):", fg="red", bold=True)
+    for f in result["findings"]:
+        loc = f.get("component") or (f"seq {f['seq']}" if "seq" in f else "-")
+        typer.echo(f"      • [{f['severity']}] {f['rule']} ({loc}): {f['detail']}")
+    typer.echo("")
+    raise typer.Exit(1)
+
+
+@app.command()
+def keygen(show_private: bool = typer.Option(False, "--show-private", help="Print the private key path.")):
+    """Show (or create) the local ed25519 signing key."""
+    key = sign.load_or_create_key()
+    pub_b64 = sign._pub_b64(key.public_key())
+    path = sign.default_key_path()
+    typer.secho("  ABOM signing key", fg="cyan", bold=True)
+    typer.echo(f"  key_id:     {sign.key_id(pub_b64)}")
+    typer.echo(f"  public_key: {pub_b64}")
+    if show_private:
+        typer.echo(f"  private:    {path}")
+    typer.secho(f"  stored at {path} (override with ABOM_KEY)", fg="bright_black")
+
+
+@app.command()
+def version():
+    """Print the abom and ABOM-spec versions."""
+    typer.echo(f"abom {__version__} · ABOM spec v{bom.ABOM_VERSION}")
+
+
+if __name__ == "__main__":
+    app()

abom/config.py

@@ -0,0 +1,37 @@
+"""Runtime configuration, loaded from environment / .env (see .env.example)."""
+from __future__ import annotations
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="ABOM_", env_file=".env", extra="ignore")
+
+    # storage / infra
+    database_url: str = "postgresql+asyncpg://abom:abom@localhost:5432/abom"
+    temporal_host: str = "localhost:7233"
+    temporal_namespace: str = "default"
+    task_queue: str = "abom-cli"
+
+    s3_endpoint: str = "http://localhost:9000"
+    s3_access_key: str = "minioadmin"
+    s3_secret_key: str = "minioadmin"
+    s3_bucket: str = "abom-artifacts"
+
+    # model serving (local, OpenAI-compatible — e.g. vLLM)
+    model_base_url: str = "http://localhost:8001/v1"
+    model_name: str = "local/qwen2.5-coder"
+    model_use_mock: bool = True  # MVP default: run without a GPU
+
+    # auth
+    oidc_jwks_url: str = ""               # empty -> dev mode
+    oidc_audience: str = "abom"
+    dev_static_token: str = "dev-token"   # dev only
+
+    # execution
+    sandbox_image: str = "python:3.12-slim"
+    workspace_root: str = "/tmp/abom-workspaces"
+    gate_timeout_seconds: int = 600
+
+
+settings = Settings()