nobrainer-tech-flow 0.0.0-stage → 2.4.0

package/skills/nobrainer-tech-flow/scripts/decision_config.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Inspect or explicitly set non-secret optional decision preferences."""
+import argparse
+import json
+import os
+from pathlib import Path
+import tempfile
+
+
+DEFAULT = {
+    "schema_version": 1,
+    "provider": "core",
+    "mode": "off",
+    "model": None,
+    "timeout_seconds": 10,
+    "max_calls_per_run": 0,
+}
+MODELS = {"core": None, "jev": "jev-latest", "laya": "aac6fef/laya-multilingual-mlx"}
+
+
+def validate(value):
+    if not isinstance(value, dict) or set(value) != set(DEFAULT):
+        raise ValueError("Configuration fields do not match schema version 1")
+    if type(value["schema_version"]) is not int or value["schema_version"] != 1:
+        raise ValueError("Unsupported schema version")
+    if not isinstance(value["provider"], str) or value["provider"] not in MODELS or value["mode"] not in ("off", "shadow"):
+        raise ValueError("Unknown provider or mode")
+    if value["provider"] == "core":
+        if value["mode"] != "off" or value["model"] is not None or value["max_calls_per_run"] != 0:
+            raise ValueError("Core profile requires off mode, no model and zero calls")
+    elif not isinstance(value["model"], str) or not value["model"].strip():
+        raise ValueError("An optional provider requires a model identifier")
+    for field, low, high in (("timeout_seconds", 1, 120), ("max_calls_per_run", 0, 100)):
+        if type(value[field]) is not int or not low <= value[field] <= high:
+            raise ValueError(f"Invalid {field}")
+    if value["mode"] == "shadow" and value["max_calls_per_run"] == 0:
+        raise ValueError("Shadow mode requires a positive call limit")
+    return value
+
+
+def read(path):
+    if not path.exists():
+        return {"status": "DEFAULT_CORE", "configured": False, "config": dict(DEFAULT)}
+    try:
+        value = validate(json.loads(path.read_text(encoding="utf-8")))
+        return {"status": "CONFIGURED", "configured": True, "config": value}
+    except (OSError, ValueError, TypeError):
+        return {"status": "INVALID_CONFIG_CORE_FALLBACK", "configured": True, "config": dict(DEFAULT)}
+
+
+def configure(path, provider, mode, model, timeout, calls):
+    value = validate({"schema_version": 1, "provider": provider, "mode": mode,
+                      "model": model, "timeout_seconds": timeout, "max_calls_per_run": calls})
+    if path.is_symlink():
+        raise ValueError("Refusing to replace a symlink configuration")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=".flow-config-")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as stream:
+            json.dump(value, stream, indent=2)
+            stream.write("\n")
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    return read(path)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--config", type=Path, default=Path(".nobrainer/flow.json"))
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("show")
+    setup = sub.add_parser("setup")
+    setup.add_argument("--non-interactive", action="store_true")
+    setter = sub.add_parser("set")
+    setter.add_argument("--provider", choices=tuple(MODELS), required=True)
+    setter.add_argument("--mode", choices=("off", "shadow"), default="off")
+    setter.add_argument("--model")
+    setter.add_argument("--timeout", type=int, default=10)
+    setter.add_argument("--max-calls", type=int, default=0)
+    args = parser.parse_args()
+    try:
+        if args.command == "setup":
+            result = read(args.config)
+            if not result["configured"]:
+                import sys
+                choice = "core"
+                if not args.non_interactive and sys.stdin.isatty():
+                    choice = input("Optional decisions: enter core (default), jev (remote), or laya (local): ").strip().lower() or "core"
+                if choice not in MODELS:
+                    raise ValueError("Unknown choice")
+                # Remember provider choice without authorizing data or charges.
+                result = configure(args.config, choice, "off", MODELS[choice], 10, 0)
+        else:
+            result = read(args.config) if args.command == "show" else configure(
+            args.config, args.provider, args.mode, args.model or MODELS[args.provider],
+            args.timeout, args.max_calls)
+    except (ValueError, OSError):
+        print(json.dumps({"status": "CONFIG_NOT_SAVED"}))
+        return 2
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/nobrainer-tech-flow/scripts/flow_guard.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Optional Claude Code guards for nobrainer-tech-flow.
+
+``pre-tool`` reads a PreToolUse payload and asks the person before a common risky
+shell command; it never denies. ``stop`` reads a Stop or SubagentStop payload and
+blocks the stop once when a turn that edited files or ran commands ends without a
+proof line. Both fail open: input they cannot read is allowed, with a note on stderr.
+
+This is a seatbelt, not a security boundary. It reads the command text, so a
+command hidden behind ``sh -c``, a variable or an alias can pass unnoticed, and a
+risky phrase inside a quoted string can ask without need.
+
+Install with ``scripts/install_guards.py``; the field names follow
+https://code.claude.com/docs/en/hooks.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import sys
+import tempfile
+from pathlib import Path
+
+
+# One shell command: the text up to the next separator.
+ARGS = r"[^;&|\n]*?"
+# Global options between a tool and its subcommand, each "-x", "--name=value" or an
+# option and one value word, as in "npm -w pkg publish" or "gh -R owner/repo release".
+# Narrower than ARGS, so "npm run publish" or "gh issue create --title release" pass.
+OPTIONS = r"(?:\s+-[^\s;&|]+(?:\s+[^\s;&|-][^\s;&|]*)?)*"
+END = r"(?=\s|$|[;&|)])"
+RISKY = (
+    # --force-with-lease and a "+branch" refspec ask too: they still rewrite the remote.
+    (re.compile(rf"\bgit\b{ARGS}\spush\b{ARGS}\s(?:--force\S*|-[a-zA-Z]*f[a-zA-Z]*|\+[A-Za-z]\S*){END}"),
+     "git push --force rewrites the remote branch"),
+    (re.compile(rf"\bgit\b{ARGS}\sreset\b{ARGS}\s--hard\b"), "git reset --hard discards uncommitted work"),
+    (re.compile(rf"\bgit\b{ARGS}\sclean\b{ARGS}\s(?:--force\b|-[a-zA-Z]*f)"),
+     "git clean -f deletes untracked files"),
+    (re.compile(rf"\bvercel\b{ARGS}\s--prod\b"), "vercel --prod deploys to production"),
+    (re.compile(rf"\bnpm\b{OPTIONS}\s+publish{END}"), "npm publish releases a package"),
+    (re.compile(rf"\bterraform\b{ARGS}\s(?:apply|destroy)\b"), "terraform apply or destroy changes infrastructure"),
+    (re.compile(rf"\bkubectl\b{ARGS}\sdelete\b"), "kubectl delete removes cluster resources"),
+    (re.compile(rf"\bgh\b{OPTIONS}\s+release\s+create{END}"), "gh release create publishes a release"),
+)
+# An rm, also path-qualified as /bin/rm or quoted as "rm", that is not part of "git rm";
+# its arguments run to the next separator.
+RM = re.compile(r"(?<![\w./-])[\"']?(?:[\w.-]*/)*rm[\"']?(?=\s)([^;&|\n)]*)")
+# Commands are matched one segment at a time. A segment this long that names a risky
+# tool is asked about whole, because the patterns slow down sharply on long lines.
+SEPARATOR = re.compile(r"[;&|\n]")
+LONGEST_SEGMENT = 2000
+RISKY_TOOL = re.compile(r"\b(?:git|vercel|npm|terraform|kubectl|gh)\b")
+# A directory change before an rm means the hook's cwd no longer says where a relative
+# target is, so the temporary-folder exemption cannot apply to it.
+CHANGE_DIRECTORY = re.compile(r"(?<![\w./-])(?:cd|pushd|popd)(?=\s|$|[;&|)])")
+RECURSIVE = re.compile(r"^(?:-[a-zA-Z]*[rR][a-zA-Z]*|--recursive)$")
+TEMP_ROOTS = ("/tmp", "/private/tmp", "/var/folders", "/private/var/folders")
+TMPDIR_REFERENCE = re.compile(r"^(?:\$TMPDIR|\$\{TMPDIR\})(?=/|$)")
+EDITING_TOOLS = {"Edit", "MultiEdit", "Write", "NotebookEdit", "Bash"}
+# A proof line may sit in a bulleted or numbered list item, with the label in bold.
+PROOF_LINE = re.compile(r"^[\s>*_\-]*(?:\d+[.)]\s*)?(?:\*\*|__)?(?:Proof|Checked)(?:\*\*|__)?:", re.MULTILINE)
+STOP_REASON = (
+    "Flow guard: this turn changed files or ran commands, but the final message has no "
+    "proof. Add a line starting with 'Proof:' or 'Checked:' that names the command, test "
+    "or readback showing the result, or say UNVERIFIED and what is missing."
+)
+
+
+def note(message: str) -> None:
+    print(f"flow_guard: {message}", file=sys.stderr)
+
+
+def temp_roots() -> list[str]:
+    roots = list(TEMP_ROOTS)
+    for value in (os.environ.get("TMPDIR"), tempfile.gettempdir()):
+        if value and os.path.isabs(value):
+            roots.append(os.path.normpath(value))
+    # Compared with real paths below, so each root counts in its real form as well
+    # (/tmp is /private/tmp on macOS).
+    return sorted({form for root in roots for form in (root, os.path.realpath(root))})
+
+
+def inside_temp(argument: str, cwd: str | None, roots: list[str]) -> bool:
+    """Whether ARGUMENT names a path strictly inside a temporary folder."""
+
+    tmpdir = os.environ.get("TMPDIR") or tempfile.gettempdir()
+    argument = TMPDIR_REFERENCE.sub(lambda _: tmpdir, argument)
+    if "$" in argument or "`" in argument or argument.startswith("~"):
+        return False
+    if not os.path.isabs(argument):
+        if not cwd or not os.path.isabs(cwd):
+            return False
+        argument = os.path.join(cwd, argument)
+    # Links on the way are followed before any "..", as the shell does: a folder under
+    # /tmp that links to a project is the project, and its real place decides.
+    path = os.path.realpath(argument)
+    return any(path.startswith(root.rstrip("/") + "/") for root in roots)
+
+
+def risky_rm(command: str, cwd: str | None) -> str | None:
+    roots = temp_roots()
+    for match in RM.finditer(command):
+        before = SEPARATOR.split(command[: match.start()])[-1].split()
+        if before and os.path.basename(before[-1]) == "git":
+            continue
+        base = None if CHANGE_DIRECTORY.search(command, 0, match.start()) else cwd
+        try:
+            words = shlex.split(match.group(1))
+        except ValueError:
+            # An open quote means a separator inside it cut the arguments short, or the
+            # "rm" is only a word in quoted text. Only a recursive rm is asked about.
+            rest = command[match.start(1):].split("\n")[0].split()
+            if any(RECURSIVE.match(word.strip("\"'")) for word in rest):
+                return "rm -r with arguments the guard cannot read deletes files for good"
+            continue
+        if not any(RECURSIVE.match(word) for word in words):
+            continue
+        paths = [word for word in words if not word.startswith("-")]
+        if not paths or not all(inside_temp(path, base, roots) for path in paths):
+            return "rm -r outside a temporary folder deletes files for good"
+    return None
+
+
+def pre_tool(payload: dict) -> dict | None:
+    if payload.get("tool_name") != "Bash":
+        return None
+    tool_input = payload.get("tool_input")
+    command = tool_input.get("command") if isinstance(tool_input, dict) else None
+    if not isinstance(command, str):
+        return None
+    cwd = payload.get("cwd") if isinstance(payload.get("cwd"), str) else None
+    # A backslash line continuation is one command, so join it before splitting.
+    command = command.replace("\\\n", " ")
+    reasons = []
+    for segment in SEPARATOR.split(command):
+        if len(segment) > LONGEST_SEGMENT and RISKY_TOOL.search(segment):
+            reasons.append("a long command names a risky tool and is too long to check")
+            continue
+        reasons += [reason for pattern, reason in RISKY if pattern.search(segment) and reason not in reasons]
+    rm = risky_rm(command, cwd)
+    if rm:
+        reasons.insert(0, rm)
+    if not reasons:
+        return None
+    return {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "ask",
+            "permissionDecisionReason": (
+                f"Flow guard: {'; '.join(reasons)}. Confirm only if this is intended "
+                "(a seatbelt check, not a security boundary)."
+            ),
+        }
+    }
+
+
+def blocks(entry: dict) -> list:
+    message = entry.get("message")
+    content = message.get("content") if isinstance(message, dict) else None
+    if isinstance(content, str):
+        return [{"type": "text", "text": content}]
+    return [block for block in content if isinstance(block, dict)] if isinstance(content, list) else []
+
+
+def read_turn(path: Path, skip_sidechain: bool) -> tuple[set[str], str]:
+    """The tools the last turn used and its final assistant text.
+
+    A turn starts at the last user entry that is a prompt rather than tool results.
+    Lines that are not JSON (a line still being written) are skipped.
+    """
+
+    entries = []
+    with path.open(encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            try:
+                entry = json.loads(line)
+            except ValueError:
+                continue
+            if not isinstance(entry, dict) or entry.get("type") not in ("user", "assistant"):
+                continue
+            if skip_sidechain and entry.get("isSidechain"):
+                continue
+            entries.append(entry)
+    if not entries:
+        raise ValueError(f"no transcript entries in {path}")
+    start = 0
+    for index, entry in enumerate(entries):
+        if entry["type"] == "user" and not any(block.get("type") == "tool_result" for block in blocks(entry)):
+            start = index
+    tools: set[str] = set()
+    final = ""
+    for entry in entries[start:]:
+        if entry["type"] != "assistant":
+            continue
+        for block in blocks(entry):
+            if block.get("type") == "tool_use" and isinstance(block.get("name"), str):
+                tools.add(block["name"])
+        text = "\n".join(
+            block["text"] for block in blocks(entry) if block.get("type") == "text" and isinstance(block.get("text"), str)
+        )
+        if text.strip():
+            final = text
+    return tools, final
+
+
+def stop(payload: dict) -> dict | None:
+    if payload.get("stop_hook_active") is True:
+        return None
+    event = payload.get("hook_event_name")
+    transcript = payload.get("agent_transcript_path") if event == "SubagentStop" else None
+    transcript = transcript or payload.get("transcript_path")
+    if not isinstance(transcript, str) or not transcript:
+        note("no transcript path in the payload; allowing the stop")
+        return None
+    try:
+        tools, final = read_turn(Path(transcript).expanduser(), skip_sidechain=event != "SubagentStop")
+    except (OSError, ValueError) as exc:
+        note(f"cannot read the transcript ({exc}); allowing the stop")
+        return None
+    if not tools & EDITING_TOOLS:
+        return None
+    message = payload.get("last_assistant_message")
+    text = message if isinstance(message, str) else final
+    if PROOF_LINE.search(text) or "UNVERIFIED" in text:
+        return None
+    return {"decision": "block", "reason": STOP_REASON}
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else argv
+    if len(argv) != 1 or argv[0] not in ("pre-tool", "stop"):
+        print("usage: flow_guard.py pre-tool|stop  (reads the hook payload on stdin)", file=sys.stderr)
+        return 1
+    try:
+        payload = json.loads(sys.stdin.read())
+    except ValueError as exc:
+        note(f"cannot parse the hook input ({exc}); allowing")
+        return 0
+    if not isinstance(payload, dict):
+        note("the hook input is not a JSON object; allowing")
+        return 0
+    result = pre_tool(payload) if argv[0] == "pre-tool" else stop(payload)
+    if result is not None:
+        print(json.dumps(result))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/nobrainer-tech-flow/scripts/typed_decisions.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Bounded advisory typed decisions; never executes selected actions."""
+import argparse
+import json
+import math
+import os
+import platform
+from pathlib import Path
+import subprocess
+import sys
+import time
+import urllib.request
+
+from decision_config import read
+
+
+def finite(value, low, high):
+    return type(value) in (int, float) and math.isfinite(value) and low <= value <= high
+
+
+def validate_request(request):
+    if not isinstance(request, dict) or set(request) != {"state", "questions"}:
+        raise ValueError("request_fields")
+    if not isinstance(request["state"], (str, dict, list)):
+        raise ValueError("state")
+    questions = request["questions"]
+    if not isinstance(questions, dict) or not 1 <= len(questions) <= 16:
+        raise ValueError("questions")
+    for key, question in questions.items():
+        if not isinstance(key, str) or not key or not isinstance(question, dict):
+            raise ValueError("question")
+        if not isinstance(question.get("instructions"), (str, dict, list)) or not question["instructions"]:
+            raise ValueError("instructions")
+        kind = question.get("type")
+        criteria = question.get("criteria")
+        if kind == "choice":
+            if not isinstance(criteria, dict) or not criteria or not all(isinstance(k, str) and k for k in criteria):
+                raise ValueError("choice_criteria")
+        elif kind == "score":
+            if not isinstance(criteria, list) or len(criteria) < 2:
+                raise ValueError("score_criteria")
+        elif kind != "noul":
+            raise ValueError("question_type")
+    return request
+
+
+def validate_answers(request, response):
+    answers = response.get("answers") if isinstance(response, dict) else None
+    if not isinstance(answers, dict) or set(answers) != set(request["questions"]):
+        raise ValueError("answer_ids")
+    clean = {}
+    for key, question in request["questions"].items():
+        answer = answers[key]
+        kind = question["type"]
+        if not isinstance(answer, dict) or answer.get("type") != kind:
+            raise ValueError("answer_type")
+        if kind == "noul":
+            if not finite(answer.get("noul"), 0, 1):
+                raise ValueError("noul")
+            clean[key] = {"type": kind, "noul": answer["noul"]}
+            continue
+        keys = set(question["criteria"]) if kind == "choice" else {str(i) for i in range(len(question["criteria"]))}
+        probabilities = answer.get("probabilities")
+        if not isinstance(probabilities, dict) or set(probabilities) != keys:
+            raise ValueError("distribution_keys")
+        if not all(finite(p, 0, 1) for p in probabilities.values()) or abs(sum(probabilities.values()) - 1) > 0.02:
+            raise ValueError("distribution_values")
+        if not finite(answer.get("confidence"), 0, 1):
+            raise ValueError("confidence")
+        value = answer.get(kind)
+        if kind == "choice" and (not isinstance(value, str) or value not in keys):
+            raise ValueError("choice")
+        if kind == "score" and not finite(value, 0, len(keys) - 1):
+            raise ValueError("score")
+        clean[key] = {"type": kind, kind: value, "confidence": answer["confidence"], "probabilities": probabilities}
+    return clean
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        raise ValueError("redirect_not_allowed")
+
+
+def worker(provider, model, request):
+    if provider == "jev":
+        key = os.environ.get("TYPESAFE_API_KEY")
+        if not key:
+            return {"error": "MISSING_TYPESAFE_API_KEY"}
+        payload = json.dumps(dict(request, model=model)).encode()
+        req = urllib.request.Request("https://api.typesafe.ai/v1/systemone", data=payload,
+                                     headers={"Authorization": "Bearer " + key, "Content-Type": "application/json"})
+        with urllib.request.build_opener(NoRedirect).open(req, timeout=120) as response:
+            raw = response.read(1_000_001)
+        if len(raw) > 1_000_000:
+            return {"error": "RESPONSE_TOO_LARGE"}
+        return json.loads(raw)
+    if provider != "laya":
+        return {"error": "UNKNOWN_PROVIDER"}
+    if platform.system() != "Darwin" or platform.machine() != "arm64":
+        return {"error": "UNSUPPORTED_LOCAL_RUNTIME"}
+    # Never fetch weights implicitly: model must already be available offline.
+    os.environ["HF_HUB_OFFLINE"] = "1"
+    os.environ["TRANSFORMERS_OFFLINE"] = "1"
+    try:
+        import laya_mlx
+        from huggingface_hub import snapshot_download
+    except ImportError:
+        return {"error": "MISSING_LOCAL_RUNTIME"}
+    if not Path(model).is_dir():
+        try:
+            model_path = snapshot_download(model, local_files_only=True, allow_patterns=[
+                "model.safetensors", "rl_agent_config.json", "encoder/config.json", "tokenizer/*", "mlx_config.json"])
+        except Exception:
+            return {"error": "MISSING_LOCAL_MODEL"}
+    else:
+        model_path = model
+    try:
+        agent = laya_mlx.load(model_path, dtype="float16")
+    except Exception:
+        return {"error": "INCOMPATIBLE_LOCAL_MODEL"}
+    result = agent.predict(request["state"], request["questions"])
+    result["model"] = model
+    return result
+
+
+def invoke(provider, model, request, timeout):
+    env = {k: v for k, v in os.environ.items()
+           if not any(part in k.upper() for part in ("KEY", "TOKEN", "SECRET", "PASSWORD", "CREDENTIAL"))}
+    if provider == "jev" and os.environ.get("TYPESAFE_API_KEY"):
+        env["TYPESAFE_API_KEY"] = os.environ["TYPESAFE_API_KEY"]
+    process = subprocess.run([sys.executable, str(Path(__file__).resolve()), "--worker", provider, model],
+                             input=json.dumps(request), capture_output=True, text=True,
+                             timeout=timeout, env=env)
+    if process.returncode:
+        raise ValueError("provider_failed")
+    return json.loads(process.stdout)
+
+
+def evaluate(requests, configuration, approved=False, call=invoke):
+    cfg = configuration["config"]
+    results = []
+    attempted = 0
+    for request in requests:
+        reason = None
+        if configuration["status"] == "INVALID_CONFIG_CORE_FALLBACK":
+            reason = "INVALID_CONFIG"
+        elif cfg["mode"] == "off" or cfg["provider"] == "core":
+            reason = "OFF"
+        elif not approved:
+            reason = "DATA_NOT_APPROVED"
+        elif attempted >= cfg["max_calls_per_run"]:
+            reason = "CALL_LIMIT"
+        started = time.monotonic()
+        result = {"status": "CORE_FALLBACK", "provider": cfg["provider"], "model": cfg["model"]}
+        if reason is None:
+            try:
+                validate_request(request)
+                attempted += 1
+                response = call(cfg["provider"], cfg["model"], request, cfg["timeout_seconds"])
+                if isinstance(response, dict) and response.get("error"):
+                    allowed = {"MISSING_TYPESAFE_API_KEY", "UNSUPPORTED_LOCAL_RUNTIME", "MISSING_LOCAL_RUNTIME",
+                               "MISSING_LOCAL_MODEL", "INCOMPATIBLE_LOCAL_MODEL", "UNKNOWN_PROVIDER"}
+                    reason = response["error"] if isinstance(response["error"], str) and response["error"] in allowed else "INVALID_OR_UNAVAILABLE"
+                else:
+                    result["answers"] = validate_answers(request, response)
+                    result["status"] = "SHADOW_SUGGESTION"
+                    model = response.get("model")
+                    result["model"] = model if isinstance(model, str) and len(model) <= 128 else cfg["model"]
+            except subprocess.TimeoutExpired:
+                reason = "TIMEOUT"
+            except (ValueError, TypeError, KeyError, OSError):
+                reason = "INVALID_OR_UNAVAILABLE"
+        result.update(reason=reason, calls_used=attempted,
+                      elapsed_seconds=round(time.monotonic() - started, 6))
+        results.append(result)
+    return {"status": "ADVISORY_ONLY", "calls_used": attempted, "results": results}
+
+
+def main():
+    if len(sys.argv) == 4 and sys.argv[1] == "--worker":
+        try:
+            # Third-party stdout may contain progress or input; contain it.
+            import contextlib
+            import io
+            request = validate_request(json.load(sys.stdin))
+            with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+                result = worker(sys.argv[2], sys.argv[3], request)
+            print(json.dumps(result))
+            return 0
+        except Exception:
+            print(json.dumps({"error": "PROVIDER_UNAVAILABLE"}))
+            return 2
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--config", type=Path, default=Path(".nobrainer/flow.json"))
+    parser.add_argument("--request", type=Path, help="JSON array of requests; otherwise stdin")
+    parser.add_argument("--approved-data", action="store_true", help="Only with existing approval for this data and provider")
+    args = parser.parse_args()
+    try:
+        data = json.loads(args.request.read_text()) if args.request else json.load(sys.stdin)
+        if not isinstance(data, list) or len(data) > 100:
+            raise ValueError("batch")
+        print(json.dumps(evaluate(data, read(args.config), args.approved_data), ensure_ascii=False))
+        return 0
+    except (OSError, ValueError, TypeError):
+        print(json.dumps({"status": "CORE_FALLBACK", "reason": "INVALID_INPUT"}))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())