multi-forge 1.0.2__tar.gz → 1.1.0__tar.gz

{multi_forge-1.0.2 → multi_forge-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: multi-forge
-Version: 1.0.2
+Version: 1.1.0
 Summary: Multi-runtime agent toolkit: proxy routing, cost control, session management, policy enforcement, and workflow orchestration
 Project-URL: Homepage, https://github.com/hapa1i/multi-forge
 Project-URL: Repository, https://github.com/hapa1i/multi-forge
@@ -47,7 +47,7 @@ Requires-Dist: pyyaml<7,>=6.0.3
 Requires-Dist: redis<8,>=5.2.0
 Requires-Dist: rich<14,>=13.9.4
 Requires-Dist: ruamel-yaml>=0.18.0
-Requires-Dist: starlette<1.4,>=1.3.1
+Requires-Dist: starlette<1.8,>=1.7.0
 Requires-Dist: tenacity>=8.0.0
 Requires-Dist: uvicorn<1,>=0.33.0
 Requires-Dist: uvloop<1,>=0.21.0; sys_platform != 'win32'

{multi_forge-1.0.2 → multi_forge-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "multi-forge"
-version = "1.0.2"
+version = "1.1.0"
 description = "Multi-runtime agent toolkit: proxy routing, cost control, session management, policy enforcement, and workflow orchestration"
 readme = "README.md"
 license = "Apache-2.0"
@@ -53,8 +53,7 @@ dependencies = [
     "cryptography>=50.0.0",
     # LiteLLM 1.95 imports outbound-credential tagged unions at startup.
     "expression>=5.6.0,<6",
-    # Keep the lock-proven FastAPI/Starlette pair while their newer route-tree
-    # behavior is verified separately from this LiteLLM/model-support update.
+    # Keep FastAPI's lock-proven route-tree behavior; upgrade it separately.
     "fastapi>=0.136.3,<0.137",
     "fastapi-sso>=0.19.0,<1",
     "orjson>=3.11.6,<4",
@@ -63,7 +62,8 @@ dependencies = [
     "python-multipart>=0.0.31,<1",
     # LiteLLM 1.95 imports its Redis support from the default startup graph.
     "redis>=5.2.0,<8",
-    "starlette>=1.3.1,<1.4",
+    # Starlette 1.7 fixes TestClient's deprecated AnyIO BlockingPortal import.
+    "starlette>=1.7.0,<1.8",
     "uvicorn>=0.33.0,<1",
     "uvloop>=0.21.0,<1; sys_platform != 'win32'",
     "watchfiles>=0.20",

{multi_forge-1.0.2 → multi_forge-1.1.0}/src/forge/cli/activity.py

@@ -109,6 +109,17 @@ def _render(summary: SessionActivitySummary, *, period: str) -> None:
         "not your full interactive session.[/dim]"
     )
 
+    if summary.turn_review:
+        turn = summary.turn_review
+        console.print(
+            f"[bold]Stop review[/bold]: {turn['state']} · spent={turn.get('spent', 'unknown')} · {turn.get('reason') or 'bounded snapshot'}"
+        )
+    if summary.supervisor_reviews:
+        latest = summary.supervisor_reviews[0]
+        console.print(
+            f"Supervisor review: {latest['state']} at {latest['started_at']} ({latest.get('reason') or latest.get('verdict') or 'running'})"
+        )
+
     pol = summary.policy
     # Fail-open breakdown is ledger-derived (the supervisor CommandUsage), so the
     # Supervisor line must render even when there is no decision log (pol is None) --

{multi_forge-1.0.2 → multi_forge-1.1.0}/src/forge/cli/hooks/__init__.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 # The Click group — imported by cli/main.py
 from ._group import hooks
+from . import codex_stop as _codex_stop  # noqa: F401 -- registers dedicated Codex turn hooks
 from . import commands as _commands  # noqa: F401  — registers @hooks.command() decorators
 from .verification import (
     _get_last_assistant_text_for_verification,

{multi_forge-1.0.2 → multi_forge-1.1.0}/src/forge/cli/hooks/codex_patch.py

@@ -48,6 +48,7 @@ class PatchFileOp:
     move_to: str | None
     added_content: str  # introduced lines ("" for delete)
     raw_section: str  # verbatim header + body (raw_diff source)
+    source_path: str | None = None
 
 
 @dataclass
@@ -65,6 +66,7 @@ class _Section:
             move_to=self.move_to,
             added_content="" if self.kind == "delete" else _extract_codex_added_lines(self.body),
             raw_section="\n".join(self.header_lines + self.body),
+            source_path=self.path if self.move_to else None,
         )
 
 

{multi_forge-1.0.2 → multi_forge-1.1.0}/src/forge/cli/hooks/codex_policy.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 import json
 import os
 from collections.abc import Callable
+from dataclasses import replace
 from pathlib import Path
 from typing import Any
 
@@ -42,6 +43,11 @@ class CodexHookAdapter:
 
     ORIGIN = "codex"
 
+    def __init__(self, *, native_review: bool = False) -> None:
+        # Only native review consumes the executor boundary; deriving it spawns a
+        # process probe, which ordinary policy checks must not pay per edit.
+        self._native_review = native_review
+
     def build_contexts(self, payload: dict[str, Any], tool_name: str, manifest: Any) -> list[ActionContext]:
         """Build per-file ``ActionContext``s from a Codex PreToolUse payload ([] if unbuildable)."""
         if tool_name != "apply_patch":
@@ -63,7 +69,16 @@ class CodexHookAdapter:
         cwd = Path(payload_cwd) if isinstance(payload_cwd, str) and payload_cwd else Path(os.getcwd())
         cwd = cwd.resolve()
 
-        return [self._context_for_op(op, cwd, manifest) for op in ops if op.kind != "delete"]
+        boundary = None
+        if self._native_review:
+            from forge.core.runtime.codex_review_source import boundary_from_hook
+
+            boundary = boundary_from_hook(payload)
+        return [
+            replace(self._context_for_op(op, cwd, manifest), native_boundary=boundary)
+            for op in ops
+            if op.kind != "delete"
+        ]
 
     def _context_for_op(self, op: PatchFileOp, cwd: Path, manifest: Any) -> ActionContext:
         # Normalize to the tool names every policy's applies_to expects.
@@ -150,15 +165,10 @@ class CodexHookResponder:
         return self._deny_wire(reason)
 
     def allow_feedback(self, additional_context: str) -> dict[str, Any]:
-        """Build the allow JSON (protocol conformance only).
-
-        Not emitted in Phase 3: PreToolUse ``additionalContext`` delivery on allow is
-        unprobed (only SessionStart's is confirmed), so the command allows silently.
-        """
+        """Build bare context: explicit allow suppresses delivery on measured Codex."""
         return {
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
-                "permissionDecision": "allow",
                 "additionalContext": additional_context,
             }
         }

multi_forge-1.1.0/src/forge/cli/hooks/codex_policy_feedback.py

@@ -0,0 +1,317 @@
+"""Pure, bounded audience projection of already evaluated Codex policy results."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from forge.cli.hooks.policy import DENY_NOTE, NEEDS_REVIEW_GUIDANCE
+from forge.policy.semantic.stop_review import StopOutcome
+from forge.policy.types import CompositeDecision, PolicyDecision, Violation
+
+FIELD_CHARS = 600
+FINDING_BYTES = 2400
+FINDING_LIMIT = 12
+MODEL_BYTES = 12000
+OPERATOR_BYTES = 5000
+WIRE_BYTES = 20000
+_INSPECT = "Inspect: forge policy supervisor status --json; forge session show <session> --json."
+_EVIDENCE_NOTICE = "Policy evidence could not be saved; the verdict is unchanged."
+_NO_QUOTE = "No verified plan quotation is available."
+_UNREVIEWED = "Policy review unavailable; this allowed action is unreviewed."
+_RECOVERY = {
+    "timeout": "Reviewer timed out. Check supervisor status and its timeout setting.",
+    "subscription_exhausted": "Reviewer subscription exhausted. Restore quota before relying on review.",
+    "auth_unavailable": "Reviewer authentication unavailable. Check the configured reviewer login.",
+    "config": "Reviewer configuration is invalid. Check supervisor status.",
+    "plan_missing": "Approved plan is unavailable. Restore the configured plan file.",
+    "parse_failure": "Reviewer response was invalid. Check supervisor status and review evidence.",
+}
+
+
+@dataclass(frozen=True)
+class _Finding:
+    path: str | None
+    policy: str
+    violation: Violation | None = None
+    intent: str | None = None
+    warning: str | None = None
+    diagnostic: str | None = None
+
+
+def render_policy_feedback(
+    file_results: list[tuple[str | None, CompositeDecision]],
+    *,
+    model_feedback: bool,
+    source_only: bool,
+    supported: bool,
+    persistence_failed: bool = False,
+) -> str | None:
+    """Select audiences without altering verdicts, records, or policy state.
+
+    New allow channels require measured executor identity. Blocking output keeps
+    the existing wire on every version. All arbitrary text is quoted JSON data;
+    quoting is attribution, not a claim of prompt-injection immunity.
+    """
+    denied = [(p, r) for p, r in file_results if r.final_decision == "deny"]
+    review = [(p, r) for p, r in file_results if r.final_decision == "needs_review"]
+    selected = denied or review or file_results
+    blocked = bool(denied or review)
+    findings, notices = _collect(selected, blocked=blocked)
+    if persistence_failed:
+        notices.append(_Finding(None, "forge.policy", diagnostic="evidence_unavailable"))
+    title = (
+        "Policy blocked this patch."
+        if denied
+        else (
+            "Policy review required; this patch remains blocked."
+            if review
+            else "Policy warnings for an allowed action."
+        )
+    )
+    model_title = title + " The following JSON entries are quoted policy evidence."
+    if denied:
+        model_title += " " + DENY_NOTE
+    elif review:
+        model_title += " " + NEEDS_REVIEW_GUIDANCE
+    wire: dict[str, Any] = {}
+    if blocked or (supported and model_feedback and findings):
+        context = _channel(findings, model_title, MODEL_BYTES, source_only=source_only, blocked=blocked)
+        hook: dict[str, str] = {"hookEventName": "PreToolUse"}
+        if blocked:
+            hook.update(permissionDecision="deny", permissionDecisionReason=context)
+        else:
+            hook["additionalContext"] = context
+        wire["hookSpecificOutput"] = hook
+    if supported and (findings or notices):
+        wire["systemMessage"] = _channel(findings + notices, title, OPERATOR_BYTES, source_only=False, operator=True)
+    if not wire:
+        return None
+    serialized = _json(wire)
+    # Field budgets count JSON-encoded strings, including escape expansion.
+    assert len(serialized.encode("utf-8")) <= WIRE_BYTES
+    return serialized
+
+
+def render_stop_feedback(outcome: StopOutcome, *, source_only: bool, model_feedback: bool) -> str | None:
+    """Stop blocks reach the model as user authority; notices are operator-only.
+
+    There is no measured non-blocking model channel for Stop. Summary-off thus
+    affects no operator notice and never removes required correction guidance.
+    """
+    wire: dict[str, Any] = {}
+    decision = outcome.decision
+    findings = _violations(None, decision, decision.violations or decision.warning_findings) if decision else []
+    if outcome.correction and decision is not None:
+        title = (
+            "Forge's supervisor found divergence in changes already made. "
+            "Address the verified plan findings, then finish. This turn receives no further semantic review. "
+            + DENY_NOTE
+            + " The following JSON entries are quoted policy evidence."
+        )
+        if not findings:
+            title += " No verified finding is available. Stop and ask the operator."
+        wire.update(
+            decision="block",
+            reason=_channel(findings, title, MODEL_BYTES, source_only=source_only, blocked=True),
+        )
+    title = {
+        "reviewed": "Forge reviewed the bounded repository snapshot; later changes are unreviewed.",
+        "no_changes": "Forge Stop review skipped: no changes or outstanding work in the captured scope.",
+        "unreviewed": "Forge Stop review is stale or has unreviewed continuation changes.",
+        "incomplete": "Forge Stop review incomplete; this turn's review allowance is spent.",
+        "partial": "Forge reviewed only the available evidence. Omitted work remains unreviewed; no correction was requested.",
+    }.get(outcome.status, "Forge Stop review unavailable; work is unreviewed.")
+    if outcome.correction:
+        title = "Forge requested one correction; the result and subsequent changes remain unreviewed."
+    if outcome.reason == "carry_limit":
+        title += (
+            " Pending work reached the carry limit. Preview forge policy supervisor reset-review before excluding it."
+        )
+    elif outcome.reason in {"incomplete_evidence", "missing_turn_start"}:
+        title += " Inspect supervisor status for excluded scope. A new explicit turn reviews new work, not the excluded history."
+    elif outcome.reason == "new_explicit_turn_required":
+        title += " Submit a new explicit turn to start after the requested reset."
+    elif outcome.status not in {"reviewed", "no_changes"}:
+        title += " Submit a new explicit turn to assess outstanding work; inspect supervisor status for unavailable evidence."
+    wire["systemMessage"] = _channel(findings, title, OPERATOR_BYTES, source_only=False, operator=True)
+    serialized = _json(wire)
+    assert len(serialized.encode()) <= WIRE_BYTES
+    return serialized
+
+
+def decision_is_unreviewed(decision: PolicyDecision) -> bool:
+    """An escalation failure alone does not make the final review unavailable."""
+    return decision.decision != "needs_review" and bool(decision.fail_open or decision.failure_type)
+
+
+def _collect(
+    results: list[tuple[str | None, CompositeDecision]], *, blocked: bool
+) -> tuple[list[_Finding], list[_Finding]]:
+    findings: list[_Finding] = []
+    notices: list[_Finding] = []
+    for path, result in results:
+        for decision in result.decisions:
+            codes = decision.diagnostic_codes
+            if "evidence_unavailable" in codes or decision.failure_type == "evidence_unavailable":
+                notices.append(_Finding(path, decision.policy_id, diagnostic="evidence_unavailable"))
+            if blocked:
+                if decision.decision != result.final_decision:
+                    continue
+                findings.extend(_violations(path, decision, decision.violations))
+                if not decision.violations:
+                    findings.append(_Finding(path, decision.policy_id, diagnostic="unresolved"))
+            elif (
+                decision.decision == "needs_review"
+                or decision.failure_type in ("skipped", "evidence_unavailable")
+                or "unconfigured" in codes
+            ):
+                continue
+            elif decision_is_unreviewed(decision):
+                findings.append(_Finding(path, decision.policy_id, diagnostic=decision.failure_type or "unavailable"))
+            elif decision.warning_findings:
+                findings.extend(_violations(path, decision, decision.warning_findings))
+            elif not codes:
+                # Legacy/free-form warnings retain their owner; source-only never
+                # treats a plain string as a verified quotation or authored policy.
+                findings.extend(_Finding(path, decision.policy_id, warning=w) for w in decision.warnings)
+        if blocked and not any(f.path == path for f in findings):
+            findings.append(_Finding(path, "forge.policy", diagnostic="unresolved"))
+    return findings, notices
+
+
+def _violations(path: str | None, decision: PolicyDecision, violations: list[Violation]) -> list[_Finding]:
+    return [_Finding(path, decision.policy_id, v, decision.intent) for v in violations]
+
+
+def _json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=True, separators=(",", ":"))
+
+
+def _projection(
+    finding: _Finding, *, source_only: bool, limit: int, operator: bool, blocked: bool
+) -> tuple[dict[str, Any], bool]:
+    truncated = False
+
+    def clip(value: object) -> str:
+        nonlocal truncated
+        text = value if isinstance(value, str) else ""
+        if len(text) > limit:
+            truncated = True
+        return text[:limit]
+
+    v = finding.violation
+    rule = v.rule_id if v else finding.policy
+    data: dict[str, Any] = {"path": clip(finding.path), "policy": clip(finding.policy), "rule": clip(rule)}
+    # A shortened path remains distinguishable from another path with the same prefix.
+    if finding.path and len(finding.path) > limit:
+        data["path_sha256"] = hashlib.sha256(finding.path.encode()).hexdigest()
+    for key, value in (("rule", rule), ("policy", finding.policy)):
+        if len(value) > limit:
+            data[key + "_sha256"] = hashlib.sha256(value.encode()).hexdigest()
+    data["label"] = clip(f"{finding.path or '?'}: [{rule}]")
+    if finding.diagnostic:
+        code = finding.diagnostic
+        if code == "evidence_unavailable":
+            data["status"] = _EVIDENCE_NOTICE
+        elif code == "unresolved":
+            data["status"] = "Review unresolved; this patch remains blocked. " + _NO_QUOTE
+        else:
+            data["status"] = _UNREVIEWED
+            if operator:
+                data["recovery"] = _RECOVERY.get(
+                    code, "Reviewer unavailable. Check supervisor status and review evidence."
+                )
+    elif source_only and (v is None or v.provenance != "policy"):
+        quotes = []
+        if v is not None:
+            for quote in v.verified_citations[:3]:
+                text = clip(quote.text)
+                quotes.append(
+                    {
+                        "source": clip(quote.source),
+                        "sha256": quote.digest,
+                        "start": quote.start,
+                        "end": quote.start + len(text),
+                        "text": text,
+                    }
+                )
+            truncated |= len(v.verified_citations) > 3
+        data["status"] = (
+            "Policy finding; verified approved-plan quotations follow."
+            if quotes
+            else "Policy reported a finding. " + _NO_QUOTE
+        )
+        data["quotes"] = quotes
+        if blocked and not quotes:
+            data["status"] += " Stop and ask the operator before retrying this finding."
+    elif v is not None:
+        data.update(
+            severity=clip(v.severity),
+            message=clip(v.message),
+            intent=clip(finding.intent),
+            evidence=clip(v.evidence),
+            suggested_fix=clip(v.suggested_fix),
+        )
+        data["citations"] = [clip(c) for c in v.citations[:3]]
+        truncated |= len(v.citations) > 3
+    else:
+        data["message"] = clip(finding.warning)
+    if truncated:
+        data["truncated"] = True
+    return data, truncated
+
+
+def _channel(
+    findings: list[_Finding],
+    title: str,
+    budget: int,
+    *,
+    source_only: bool,
+    operator: bool = False,
+    blocked: bool = False,
+) -> str:
+    # Deduplicate the full attributed finding before truncation, within this response only.
+    unique = {_json(asdict(f)): f for f in findings}
+    ordered = sorted(
+        unique.values(), key=lambda f: (f.path or "", f.policy, f.violation.rule_id if f.violation else "")
+    )
+    lines: list[str] = []
+    omitted = 0
+    truncated = 0
+    footer = "\n" + _INSPECT if operator else ""
+
+    def assemble(skipped: int, shortened: int) -> str:
+        return (
+            title
+            + "\n"
+            + "\n".join(lines)
+            + f"\nOmitted findings: {skipped}. Truncated findings: {shortened}."
+            + footer
+        )
+
+    for finding in ordered:
+        if len(lines) >= FINDING_LIMIT:
+            omitted += 1
+            continue
+        limit = FIELD_CHARS
+        data, shortened = _projection(finding, source_only=source_only, limit=limit, operator=operator, blocked=blocked)
+        while len(_json(data).encode()) > FINDING_BYTES and limit > 8:
+            limit //= 2
+            data, shortened = _projection(
+                finding, source_only=source_only, limit=limit, operator=operator, blocked=blocked
+            )
+        line = _json(data)
+        if len(line.encode()) > FINDING_BYTES:
+            omitted += 1
+            continue
+        lines.append(line)
+        # Reserve final counters at their maximum length before accepting a finding.
+        if len(_json(assemble(len(ordered), len(ordered))).encode()) > budget:
+            lines.pop()
+            omitted += 1
+        else:
+            truncated += int(shortened)
+    return assemble(omitted, truncated)