subcortex 0.3.0__py3-none-any.whl

subcortex/tuis.py

@@ -0,0 +1,51 @@
+"""Canonical TUI names and their aliases (single source for CLI, adapters, installers)."""
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+ALIASES: Dict[str, str] = {
+    "claude": "claude-code",
+    "claudecode": "claude-code",
+    "codex-cli": "codex",
+    "open-code": "opencode",
+    "kimi": "kimi-code",
+    "kimicode": "kimi-code",
+    "qodercli": "qoder",
+    "qoder-cli": "qoder",
+    "codebuddy-code": "codebuddy",
+    "factory": "droid",
+    "factory-droid": "droid",
+    "junie-cli": "junie",
+    "devin-cli": "devin",
+    "open-hands": "openhands",
+    "ampcode": "amp",
+    "gemini": "gemini-cli",
+    "qwen": "qwen-code",
+    "cursor-agent": "cursor",
+    "cursor-cli": "cursor",
+    "copilot-cli": "copilot",
+    "github-copilot": "copilot",
+    "interpreter": "open-interpreter",
+    "openinterpreter": "open-interpreter",
+    "kilocode": "kilo",
+    "kilo-code": "kilo",
+    "grok": "grok-build",
+    "cagent": "docker-agent",
+    "docker": "docker-agent",
+    "letta-code": "letta",
+    "mistral-vibe": "vibe",
+    "augment": "auggie",
+    "kiro-cli": "kiro",
+    "cline-cli": "cline",
+    "pi-coding-agent": "pi",
+}
+
+
+def canonical(name: str, known) -> Optional[str]:
+    """Canonical id for ``name`` if it (or its alias) is in ``known``."""
+    key = str(name or "").strip().lower().replace("_", "-")
+    if key in known:
+        return key
+    alias = ALIASES.get(key) or ALIASES.get(key.replace("-", ""))
+    return alias if alias in known else None

subcortex/ui.py

@@ -0,0 +1,319 @@
+"""Terminal prompts for interactive setup (stdlib only).
+
+In a real terminal, menus use the arrow keys (↑/↓ or j/k to move, space to
+toggle, a to toggle all, enter to accept, esc/q to cancel). Anywhere else —
+pipes, CI, tests — every prompt falls back to plain numbered line input, and
+with no input at all each prompt returns its default. ``Cancelled`` is raised
+when the user backs out (esc, q, ctrl-c).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from contextlib import contextmanager
+from typing import Any, Callable, Iterator, List, Optional, Sequence, Set, TextIO, Tuple
+
+Option = Tuple[Any, str, str]  # (value, label, hint)
+
+UP, DOWN, SPACE, ENTER, CANCEL, TOGGLE_ALL = "up", "down", "space", "enter", "cancel", "all"
+
+
+class Cancelled(Exception):
+    pass
+
+
+def _read_key(stream: TextIO) -> str:
+    """One keypress from a terminal in cbreak mode, normalized."""
+    ch = stream.read(1)
+    if ch == "\x1b":
+        nxt = stream.read(1)
+        if nxt == "[":
+            code = stream.read(1)
+            return {"A": UP, "B": DOWN}.get(code, "")
+        return CANCEL
+    if ch in ("\r", "\n"):
+        return ENTER
+    if ch == " ":
+        return SPACE
+    if ch in ("k",):
+        return UP
+    if ch in ("j",):
+        return DOWN
+    if ch in ("a", "A"):
+        return TOGGLE_ALL
+    if ch in ("q", "Q", "\x03", "\x04"):
+        return CANCEL
+    return ""
+
+
+class UI:
+    def __init__(self, stdin: Optional[TextIO] = None, stdout: Optional[TextIO] = None,
+                 interactive: Optional[bool] = None, color: Optional[bool] = None,
+                 keys: Optional[Iterator[str]] = None) -> None:
+        self.stdin = stdin or sys.stdin
+        self.stdout = stdout or sys.stdout
+        tty = _isatty(self.stdin) and _isatty(self.stdout) and os.environ.get("TERM") != "dumb"
+        self.interactive = tty if interactive is None else interactive
+        self.color = (tty and not os.environ.get("NO_COLOR")) if color is None else color
+        self._keys = keys  # injected keypresses (tests)
+
+    # -- output -------------------------------------------------------------------------
+
+    def _c(self, code: str, text: str) -> str:
+        return f"\x1b[{code}m{text}\x1b[0m" if self.color else text
+
+    def write(self, text: str = "") -> None:
+        self.stdout.write(text + "\n")
+        self.stdout.flush()
+
+    def title(self, text: str) -> None:
+        self.write()
+        self.write(self._c("1", f"◆ {text}"))
+
+    def step(self, n: int, total: int, text: str) -> None:
+        self.write()
+        self.write(self._c("1;36", f"[{n}/{total}] {text}"))
+
+    def info(self, text: str) -> None:
+        self.write(f"  {text}")
+
+    def dim(self, text: str) -> None:
+        self.write(self._c("2", f"  {text}"))
+
+    def ok(self, text: str) -> None:
+        self.write(f"  {self._c('32', '✓')} {text}")
+
+    def warn(self, text: str) -> None:
+        self.write(f"  {self._c('33', '!')} {text}")
+
+    def error(self, text: str) -> None:
+        self.write(f"  {self._c('31', '✗')} {text}")
+
+    # -- line input -----------------------------------------------------------------------
+
+    def _readline(self, prompt: str) -> Optional[str]:
+        self.stdout.write(prompt)
+        self.stdout.flush()
+        try:
+            line = self.stdin.readline()
+        except KeyboardInterrupt:
+            raise Cancelled()
+        if line == "":  # EOF: no more input, use defaults
+            self.stdout.write("\n")
+            return None
+        return line.rstrip("\n")
+
+    def confirm(self, question: str, default: bool = True) -> bool:
+        suffix = "[Y/n]" if default else "[y/N]"
+        while True:
+            answer = self._readline(f"  {question} {self._c('2', suffix)} ")
+            if answer is None or not answer.strip():
+                return default
+            if answer.strip().lower() in ("y", "yes"):
+                return True
+            if answer.strip().lower() in ("n", "no"):
+                return False
+            self.warn("please answer y or n")
+
+    def ask(self, question: str, default: str = "", secret: bool = False,
+            validate: Optional[Callable[[str], Optional[str]]] = None) -> str:
+        shown = f" {self._c('2', f'[{default}]')}" if default and not secret else ""
+        while True:
+            if secret and self.interactive:
+                import getpass
+
+                try:
+                    answer: Optional[str] = getpass.getpass(f"  {question}: ", stream=self.stdout)
+                except (EOFError, KeyboardInterrupt):
+                    raise Cancelled()
+            else:
+                answer = self._readline(f"  {question}{shown}: ")
+            value = default if answer is None or not answer.strip() else answer.strip()
+            problem = validate(value) if validate else None
+            if not problem:
+                return value
+            self.warn(problem)
+            if answer is None:  # no more input: don't loop forever
+                raise Cancelled()
+
+    # -- menus ------------------------------------------------------------------------------
+
+    def choose(self, question: str, options: Sequence[Option], default: int = 0) -> Any:
+        """Single choice; returns the chosen option's value."""
+        if not options:
+            raise ValueError("no options")
+        if self.interactive:
+            index = self._menu(question, options, cursor=default, multi=False, selected=set())
+            return options[index][0]
+        self.write(f"  {question}")
+        for i, (_, label, hint) in enumerate(options, 1):
+            marker = "*" if i - 1 == default else " "
+            self.write(f"   {marker}{i}) {label}" + (f" — {hint}" if hint else ""))
+        while True:
+            answer = self._readline(f"  choice {self._c('2', f'[{default + 1}]')}: ")
+            if answer is None or not answer.strip():
+                return options[default][0]
+            if answer.strip().isdigit() and 1 <= int(answer) <= len(options):
+                return options[int(answer) - 1][0]
+            self.warn(f"enter a number from 1 to {len(options)}")
+
+    def checklist(self, question: str, options: Sequence[Option], selected: Set[Any]) -> List[Any]:
+        """Multiple choice; returns the chosen values in option order."""
+        chosen = {i for i, (value, _, _) in enumerate(options) if value in selected}
+        if self.interactive:
+            self._menu(question, options, cursor=0, multi=True, selected=chosen)
+            return [options[i][0] for i in sorted(chosen)]
+        while True:
+            self.write(f"  {question}")
+            for i, (_, label, hint) in enumerate(options, 1):
+                box = "x" if i - 1 in chosen else " "
+                self.write(f"   [{box}] {i:>2}) {label}" + (f" — {hint}" if hint else ""))
+            answer = self._readline("  numbers to toggle (e.g. 1 3), 'all', 'none', or enter to accept: ")
+            if answer is None or not answer.strip():
+                return [options[i][0] for i in sorted(chosen)]
+            tokens = answer.replace(",", " ").split()
+            if tokens == ["all"]:
+                chosen = set(range(len(options)))
+            elif tokens == ["none"]:
+                chosen = set()
+            elif all(t.isdigit() and 1 <= int(t) <= len(options) for t in tokens):
+                chosen ^= {int(t) - 1 for t in tokens}
+            else:
+                self.warn(f"use numbers from 1 to {len(options)}")
+
+    def _next_key(self) -> str:
+        if self._keys is not None:
+            try:
+                return next(self._keys)
+            except StopIteration:
+                return ENTER
+        return _read_key(self.stdin)
+
+    def _menu(self, question: str, options: Sequence[Option], cursor: int, multi: bool,
+              selected: Set[int]) -> int:
+        help_text = ("↑/↓ move · space toggle · a all · enter accept · esc cancel" if multi
+                     else "↑/↓ move · enter select · esc cancel")
+        visible = min(len(options), self._max_visible())
+        scrolling = visible < len(options)
+        lines = visible + (2 if scrolling else 0)  # constant height keeps redraws aligned
+        top = 0
+        # cbreak before the question is shown: keys typed as soon as it appears
+        # must reach the menu, not get echoed and line-buffered by the terminal.
+        with self._raw_mode():
+            self.write(f"  {question}")
+            self.dim(help_text)
+            self.stdout.write("\x1b[?25l")  # hide cursor
+            try:
+                first = True
+                while True:
+                    if not first:
+                        self.stdout.write(f"\x1b[{lines}A")
+                    first = False
+                    top = min(max(top, cursor - visible + 1), cursor)  # keep the cursor in view
+                    window = range(top, top + visible)
+                    if scrolling:
+                        more = f"↑ {top} more" if top else ""
+                        self.stdout.write(f"\x1b[2K    {self._c('2', more)}\n")
+                    for i in window:
+                        _, label, hint = options[i]
+                        pointer = self._c("36", "❯") if i == cursor else " "
+                        box = ""
+                        if multi:
+                            box = (self._c("32", "◉") if i in selected else "○") + " "
+                        text = f"{label}" + (self._c("2", f"  {hint}") if hint else "")
+                        if i == cursor:
+                            text = self._c("1", label) + (self._c("2", f"  {hint}") if hint else "")
+                        self.stdout.write(f"\x1b[2K  {pointer} {box}{text}\n")
+                    if scrolling:
+                        below = len(options) - top - visible
+                        more = f"↓ {below} more" if below else ""
+                        self.stdout.write(f"\x1b[2K    {self._c('2', more)}\n")
+                    self.stdout.flush()
+                    key = self._next_key()
+                    if key == UP:
+                        cursor = (cursor - 1) % len(options)
+                    elif key == DOWN:
+                        cursor = (cursor + 1) % len(options)
+                    elif key == SPACE and multi:
+                        selected ^= {cursor}
+                    elif key == TOGGLE_ALL and multi:
+                        if len(selected) == len(options):
+                            selected.clear()
+                        else:
+                            selected.update(range(len(options)))
+                    elif key == ENTER:
+                        return cursor
+                    elif key == CANCEL:
+                        raise Cancelled()
+            finally:
+                self.stdout.write("\x1b[?25h")
+                self.stdout.flush()
+
+    def _max_visible(self) -> int:
+        """Menu rows that fit the terminal (header, help and margins excluded)."""
+        import shutil
+
+        rows = shutil.get_terminal_size(fallback=(80, 24)).lines
+        return max(5, rows - 8)
+
+    @contextmanager
+    def _raw_mode(self) -> Iterator[None]:
+        if self._keys is not None:
+            yield
+            return
+        try:
+            import termios
+            import tty
+
+            fd = self.stdin.fileno()
+            saved = termios.tcgetattr(fd)
+        except Exception:
+            yield
+            return
+        try:
+            # TCSADRAIN, not setcbreak's default TCSAFLUSH: that discards type-ahead.
+            tty.setcbreak(fd, termios.TCSADRAIN)
+            yield
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, saved)
+
+    # -- progress ---------------------------------------------------------------------------
+
+    @contextmanager
+    def spinner(self, text: str) -> Iterator[None]:
+        """Show elapsed time next to ``text`` while a slow step runs."""
+        if not self.interactive:
+            self.info(f"{text}…")
+            yield
+            return
+        done = threading.Event()
+        started = time.time()
+
+        def spin() -> None:
+            frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+            i = 0
+            while not done.wait(0.1):
+                self.stdout.write(f"\r\x1b[2K  {frames[i % len(frames)]} {text} "
+                                  f"{self._c('2', f'{time.time() - started:.0f}s')}")
+                self.stdout.flush()
+                i += 1
+
+        thread = threading.Thread(target=spin, daemon=True)
+        thread.start()
+        try:
+            yield
+        finally:
+            done.set()
+            thread.join()
+            self.stdout.write("\r\x1b[2K")
+            self.stdout.flush()
+
+
+def _isatty(stream: Any) -> bool:
+    try:
+        return bool(stream.isatty())
+    except Exception:
+        return False

subcortex/verdicts.py

@@ -0,0 +1,233 @@
+"""High-level System-1 verdicts built on typed-decision backends.
+
+Both functions take an optional ``backend`` (defaults to the configured one),
+and NEVER raise — they return ``None`` on any failure so callers fail open.
+
+Questions and thresholds are calibrated per backend against the labeled
+examples in ``subcortex.evalset`` (``subcortex eval`` reruns it; numbers in
+docs/calibration.md). The same question gets very different probability scales
+from Jev and from the local Laya model, so each backend has its own rule. A
+rule is a primary signal plus a veto: every condition must hold. Each question
+is atomic, names the state fields it reads (the model never sees question ids),
+and the evidence sits first in the state (Laya truncates the end of it).
+
+What leaves the machine for a hosted backend is bounded and redacted: the
+request, the tool call and a head+tail excerpt of the output, with anything
+that looks like a secret masked.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from . import metrics
+from .backends import get_backend
+from .backends.base import DecisionBackend
+from .config import load_config
+
+
+def _noul(instructions: str) -> Dict[str, Any]:
+    return {"type": "noul", "instructions": instructions}
+
+
+PROMPT_QUESTIONS: Dict[str, Any] = {
+    "quick": _noul("The request in `prompt` can be fully handled with one fact, one command, "
+                   "or an edit of a few lines."),
+    "multi_step": _noul("The request in `prompt` needs several dependent steps of work or reasoning."),
+    "multi_file": _noul("The request in `prompt` asks for code changes in more than one file."),
+}
+
+OUTPUT_QUESTIONS: Dict[str, Any] = {
+    "routine": _noul("`output` is routine progress or log output, such as downloads, compilation "
+                     "steps, or install messages, with nothing specific to the request in `task`."),
+    # Compound on paper, but it is the best-separating veto on both backends.
+    "needed": _noul("Is the tool output in `output`, produced by the call in `tool_call`, still "
+                    "needed to accomplish the user's request in `task` — i.e. would dropping it "
+                    "lose information that cannot be cheaply re-derived by re-running the call?"),
+    "depends": _noul("The request in `task` depends on information that appears in `output`."),
+}
+
+# (question, inverted?, threshold). Signals are oriented so that high means
+# "simple" (prompt rules) or "needed" (output rules). A prompt is simple when
+# every oriented signal is >= its threshold; an output is disposable when every
+# oriented signal is < its threshold. The first condition is the primary one:
+# it is reported, and the config threshold overrides it.
+Rule = List[Tuple[str, bool, float]]
+PROMPT_RULES: Dict[str, Rule] = {
+    # evalset, jev-1.13.0: 16/20 simple prompts hinted, 0/20 complex.
+    "jev": [("quick", False, 0.8), ("multi_step", True, 0.5)],
+    # evalset, laya multilingual: 6/20 simple, 0/20 complex (weaker model, stricter rule).
+    "laya": [("multi_step", True, 0.8), ("multi_file", True, 0.8)],
+}
+OUTPUT_RULES: Dict[str, Rule] = {
+    # evalset, jev-1.13.0: 12/12 disposable outputs trimmed, 0/12 needed ones;
+    # held out: 6/6 and 0/6.
+    "jev": [("routine", True, 0.4), ("needed", False, 0.3)],
+    # evalset, laya multilingual: 3/12 and 0/12 — but held out it trimmed 2/6
+    # NEEDED outputs (npm audit, git log). Opt-in only (see TRIMS_BY_DEFAULT).
+    "laya": [("depends", False, 0.9), ("needed", False, 0.75)],
+}
+# Backends whose output rule held up on the held-out examples. The others only
+# trim when the user sets thresholds.output_needed_threshold explicitly.
+TRIMS_BY_DEFAULT = frozenset({"jev"})
+DEFAULT_PROFILE = "laya"  # the conservative rule, for backends nobody calibrated
+
+TASK_CHARS = 600
+TOOL_CALL_CHARS = 300
+OUTPUT_EXCERPT_CHARS = 1500
+PROMPT_CHARS = 2000
+
+# -- redaction ------------------------------------------------------------------------------
+# Linear-time patterns only (no nested quantifiers): they run on every request.
+
+_SECRET_PATTERNS = [
+    re.compile(r"-----BEGIN [A-Z ]{0,40}PRIVATE KEY-----.*?(?:-----END [A-Z ]{0,40}PRIVATE KEY-----|\Z)", re.S),
+    re.compile(r"\b(?:sk|pk|rk)-[A-Za-z0-9_-]{16,}"),                   # OpenAI/Anthropic/Stripe-style
+    re.compile(r"\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{30,}|\bgithub_pat_[A-Za-z0-9_]{30,}"),
+    re.compile(r"\bxox[abposr]-[A-Za-z0-9-]{10,}"),                   # Slack
+    re.compile(r"\bAKIA[0-9A-Z]{16}\b"),                               # AWS access key id
+    re.compile(r"\bAIza[0-9A-Za-z_-]{35}\b"),                          # Google API key
+    re.compile(r"\bapikey_[0-9a-f]{16,}_[0-9a-f]{16,}\b"),             # TypeSafe
+    re.compile(r"\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}"),  # JWT
+]
+_ASSIGNMENT = re.compile(
+    r"(?i)\b([A-Z0-9_]{0,40}(?:api[_-]?key|secret|token|passw(?:or)?d|pwd|auth|credential)[A-Z0-9_]{0,40})"
+    r"([ \t]*[:=][ \t]*)([\"']?)[^\s\"']{4,}")
+_URL_CREDENTIALS = re.compile(r"(\b[a-z][a-z0-9+.-]{1,20}://)[^/\s:@]{1,100}:[^/\s@]{1,200}@")
+
+
+def redact(text: str) -> str:
+    """Mask values that look like credentials; everything else is kept."""
+    if not isinstance(text, str) or not text:
+        return text
+    for pattern in _SECRET_PATTERNS:
+        text = pattern.sub("[redacted]", text)
+    text = _ASSIGNMENT.sub(lambda m: f"{m.group(1)}{m.group(2)}{m.group(3)}[redacted]", text)
+    return _URL_CREDENTIALS.sub(r"\1[redacted]@", text)
+
+
+def excerpt(text: str, room: int = OUTPUT_EXCERPT_CHARS) -> str:
+    """Head and tail of ``text`` within ``room`` characters (as calibrated)."""
+    if len(text) <= room:
+        return text
+    return (text[:room * 2 // 3] + f"\n…[{len(text) - room} chars omitted]…\n"
+            + text[-(room // 3):])
+
+
+# -- rules ----------------------------------------------------------------------------------
+
+
+def _profile(backend: Any) -> str:
+    name = getattr(backend, "name", "")
+    return name if name in PROMPT_RULES else DEFAULT_PROFILE
+
+
+def _signals(result: Any, rule: Rule) -> Dict[str, float]:
+    answers = result["answers"]
+    raw = {}
+    for question, _, _ in rule:
+        value = float(answers[question]["noul"])
+        if not 0.0 <= value <= 1.0:
+            raise ValueError(f"{question}: not a probability")
+        raw[question] = value
+    return raw
+
+
+def _oriented(raw: Dict[str, float], rule: Rule) -> List[float]:
+    return [1.0 - raw[q] if inverted else raw[q] for q, inverted, _ in rule]
+
+
+def _override(rule: Rule, value: Any) -> Rule:
+    """The user's threshold replaces the primary condition's, when set."""
+    try:
+        threshold = float(value)
+    except (TypeError, ValueError):
+        return rule
+    if not 0.0 <= threshold <= 1.0:
+        return rule
+    question, inverted, _ = rule[0]
+    return [(question, inverted, threshold)] + rule[1:]
+
+
+def canned_answers(questions: Dict[str, Any], simple: bool = True,
+                   disposable: bool = True) -> Dict[str, Any]:
+    """What a perfectly sure model would answer: for self-tests and stubs."""
+    yes = {"quick": simple, "multi_step": not simple, "multi_file": not simple,
+           "routine": disposable, "needed": not disposable, "depends": not disposable}
+    return {"answers": {q: {"type": "noul", "noul": (1.0 if yes[q] else 0.0) if q in yes else 0.5}
+                        for q in questions}}
+
+
+# -- verdicts -------------------------------------------------------------------------------
+
+
+def classify_prompt(
+    prompt: str,
+    backend: Optional[DecisionBackend] = None,
+    config: Optional[Dict[str, Any]] = None,
+) -> Optional[Dict[str, Any]]:
+    """Classify a prompt as simple or complex.
+
+    Returns ``{"label": "simple"|"complex", "confidence": p, "signals": {...}}``
+    (``confidence`` is the primary signal oriented toward the label) or None.
+    """
+    try:
+        cfg = config or load_config()
+        be = backend or get_backend(cfg)
+        rule = _override(PROMPT_RULES[_profile(be)],
+                         (cfg.get("thresholds") or {}).get("prompt_simple_confidence"))
+        questions = {q: PROMPT_QUESTIONS[q] for q, _, _ in rule}
+        raw = _signals(be.predict({"prompt": redact(str(prompt))[:PROMPT_CHARS]}, questions), rule)
+        oriented = _oriented(raw, rule)
+        metrics.METRICS.record("verdict_prompt")
+        simple = all(p >= threshold for p, (_, _, threshold) in zip(oriented, rule))
+        primary = oriented[0]
+        return {"label": "simple" if simple else "complex",
+                "confidence": round(primary if simple else 1.0 - primary, 4),
+                "signals": {q: round(v, 4) for q, v in raw.items()}}
+    except Exception:
+        return None
+
+
+def judge_output(
+    output: str,
+    context: str = "",
+    backend: Optional[DecisionBackend] = None,
+    config: Optional[Dict[str, Any]] = None,
+    task: str = "",
+) -> Optional[Dict[str, Any]]:
+    """Judge whether a tool output is still needed or can be trimmed.
+
+    ``needed`` is False only when every condition of the backend's rule says
+    so. Without the user's request there is no evidence to judge by (and no
+    calibration), so the output is kept. Outputs shorter than
+    ``min_output_chars`` are cheap to keep and are not judged.
+    Returns ``{"needed": bool, "p_needed": float|None, "signals": {...}}`` or None.
+    """
+    try:
+        cfg = config or load_config()
+        min_chars = int(cfg["thresholds"]["min_output_chars"])
+        if len(output) < min_chars:
+            return {"needed": True, "p_needed": 1.0}
+        if not task or not task.strip():
+            return {"needed": True, "p_needed": None, "reason": "no request to judge against"}
+        be = backend or get_backend(cfg)
+        profile = _profile(be)
+        override = (cfg.get("thresholds") or {}).get("output_needed_threshold")
+        if profile not in TRIMS_BY_DEFAULT and override is None:
+            return {"needed": True, "p_needed": None,
+                    "reason": f"{profile} does not trim by default (docs/calibration.md)"}
+        rule = _override(OUTPUT_RULES[profile], override)
+        questions = {q: OUTPUT_QUESTIONS[q] for q, _, _ in rule}
+        state = {"task": redact(task.strip())[:TASK_CHARS],
+                 "tool_call": redact(str(context))[:TOOL_CALL_CHARS],
+                 "output": redact(excerpt(output))}
+        raw = _signals(be.predict(state, questions), rule)
+        oriented = _oriented(raw, rule)
+        metrics.METRICS.record("verdict_output")
+        disposable = all(p < threshold for p, (_, _, threshold) in zip(oriented, rule))
+        return {"needed": not disposable, "p_needed": round(oriented[0], 4),
+                "signals": {q: round(v, 4) for q, v in raw.items()}}
+    except Exception:
+        return None