multi-forge 0.7.0__tar.gz → 0.7.1__tar.gz

{multi_forge-0.7.0 → multi_forge-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-forge
-Version: 0.7.0
+Version: 0.7.1
 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
@@ -56,10 +56,10 @@ Description-Content-Type: text/markdown
 **Multi-runtime agent toolkit: proxy routing, cost control, session management, and policy enforcement for coding
 agents.**
 
-Forge sits between you and your coding agent (Claude Code by default, with Codex as an alternate runtime and Gemini
-next), adding persistent sessions, multi-provider model routing, cost visibility with spend caps, and autonomous
-verification. You run `forge session start` instead of `claude`; Forge then routes to your chosen model provider, tracks
-state across sessions, and enforces configured policies.
+Forge sits between you and your coding agent (Claude Code by default, with Codex as an alternate runtime), adding
+persistent sessions, multi-provider model routing, cost visibility with spend caps, and autonomous verification. You run
+`forge session start` instead of `claude`; Forge then routes to your chosen model provider, tracks state across
+sessions, and enforces configured policies.
 
 ```bash
 # Use Claude with session tracking (no proxy needed)

{multi_forge-0.7.0 → multi_forge-0.7.1}/README.md

@@ -15,10 +15,10 @@
 **Multi-runtime agent toolkit: proxy routing, cost control, session management, and policy enforcement for coding
 agents.**
 
-Forge sits between you and your coding agent (Claude Code by default, with Codex as an alternate runtime and Gemini
-next), adding persistent sessions, multi-provider model routing, cost visibility with spend caps, and autonomous
-verification. You run `forge session start` instead of `claude`; Forge then routes to your chosen model provider, tracks
-state across sessions, and enforces configured policies.
+Forge sits between you and your coding agent (Claude Code by default, with Codex as an alternate runtime), adding
+persistent sessions, multi-provider model routing, cost visibility with spend caps, and autonomous verification. You run
+`forge session start` instead of `claude`; Forge then routes to your chosen model provider, tracks state across
+sessions, and enforces configured policies.
 
 ```bash
 # Use Claude with session tracking (no proxy needed)

{multi_forge-0.7.0 → multi_forge-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "multi-forge"
-version = "0.7.0"
+version = "0.7.1"
 description = "Multi-runtime agent toolkit: proxy routing, cost control, session management, policy enforcement, and workflow orchestration"
 readme = "README.md"
 license = "Apache-2.0"

multi_forge-0.7.1/src/forge/__init__.py

@@ -0,0 +1,11 @@
+"""Multi-Forge - Multi-runtime agent toolkit."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Single source of truth is pyproject.toml; reading installed metadata keeps
+    # ``__version__`` from drifting (a hardcoded literal once shipped 0.5.0 while
+    # the package was 0.6.0, poisoning forge_version in manifests and work items).
+    __version__ = version("multi-forge")
+except PackageNotFoundError:  # source tree without an installed dist
+    __version__ = "0.0.0+unknown"

{multi_forge-0.7.0 → multi_forge-0.7.1}/src/forge/backend/registry.py

@@ -12,11 +12,10 @@ Ownership: Forge Backend Manager (`forge model backend` CLI).
 
 from __future__ import annotations
 
-import json
 import logging
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Callable, Literal
+from typing import Any, Callable, Literal, NoReturn
 
 import dacite
 
@@ -26,6 +25,7 @@ from forge.core.state import (
     StateUnreadableError,
     atomic_write_json,
     file_lock_for_target,
+    read_versioned_json_object,
 )
 
 logger = logging.getLogger(__name__)
@@ -99,6 +99,16 @@ def _uses_old_backend_id_process_records(data: object) -> bool:
     return any(isinstance(entry, dict) and "backend_id" in entry for entry in entries.values())
 
 
+def _handle_registry_version_mismatch(path: Path, data: dict[str, Any], version: Any) -> NoReturn:
+    if version == 1 and _uses_old_backend_id_process_records(data):
+        raise BackendRegistryCorruptedError(str(path), OLD_BACKEND_ID_PROCESS_FIELD_TIP)
+    raise BackendRegistryCorruptedError(
+        str(path),
+        f"incompatible version {version} (this Forge expects {BACKEND_REGISTRY_VERSION}). "
+        f"Delete this file and retry.",
+    )
+
+
 class BackendRegistryStore:
     """Manage the backend registry at ~/.forge/backends/index.json.
 
@@ -121,26 +131,14 @@ class BackendRegistryStore:
         if not self.exists():
             return BackendRegistry()
 
-        try:
-            with open(self._registry_path, encoding="utf-8") as f:
-                data = json.load(f)
-        except json.JSONDecodeError as e:
-            raise BackendRegistryCorruptedError(str(self._registry_path), f"invalid JSON: {e}")
-        except OSError as e:
-            # A failed read is environmental, not corruption -- forge clean must not delete it.
-            raise BackendRegistryUnreadableError(str(self._registry_path), f"read error: {e}")
-
-        version = data.get("version")
-        if version is None:
-            raise BackendRegistryCorruptedError(str(self._registry_path), "missing version field")
-        if version != BACKEND_REGISTRY_VERSION:
-            if version == 1 and _uses_old_backend_id_process_records(data):
-                raise BackendRegistryCorruptedError(str(self._registry_path), OLD_BACKEND_ID_PROCESS_FIELD_TIP)
-            raise BackendRegistryCorruptedError(
-                str(self._registry_path),
-                f"incompatible version {version} (this Forge expects {BACKEND_REGISTRY_VERSION}). "
-                f"Delete this file and retry.",
-            )
+        data = read_versioned_json_object(
+            self._registry_path,
+            version_key="version",
+            expected_version=BACKEND_REGISTRY_VERSION,
+            corrupted_error=BackendRegistryCorruptedError,
+            unreadable_error=BackendRegistryUnreadableError,
+            on_version_mismatch=_handle_registry_version_mismatch,
+        )
 
         try:
             return dacite.from_dict(

{multi_forge-0.7.0 → multi_forge-0.7.1}/src/forge/cli/hooks/codex_policy.py

@@ -23,7 +23,7 @@ from typing import Any
 
 from forge.cli.hooks.codex_patch import PatchFileOp, parse_apply_patch
 from forge.cli.hooks.policy import format_deny_text, format_needs_review_text
-from forge.policy.deterministic.base import is_under_directory
+from forge.policy.deterministic.base import tests_first_sort_key
 from forge.policy.types import ActionContext, CompositeDecision
 
 _MAX_CONTENT_CHARS = 5000  # same truncation convention as ClaudeHookAdapter
@@ -186,12 +186,4 @@ def sort_contexts_tests_first(contexts: list[ActionContext]) -> list[ActionConte
     patch order is preserved within each bucket.
     """
 
-    def _key(ctx: ActionContext) -> int:
-        path = ctx.target_path or ""
-        if is_under_directory(path, "tests"):
-            return 0
-        if is_under_directory(path, "src"):
-            return 2
-        return 1
-
-    return sorted(contexts, key=_key)
+    return sorted(contexts, key=lambda ctx: tests_first_sort_key(ctx.target_path))

{multi_forge-0.7.0 → multi_forge-0.7.1}/src/forge/cli/hooks/commands.py

@@ -79,6 +79,109 @@ from .verification import _run_verification_check
 logger = logging.getLogger(__name__)
 
 
+@dataclass(frozen=True)
+class _TranscriptCaptureResult:
+    copied: bool
+    dst_abs: Path
+    dst_rel: Path
+    manifest_updated: bool
+    manifest_error: str | None
+
+
+def _capture_transcript_artifact(
+    *,
+    cwd: Path,
+    store: Any,
+    manifest: Any,
+    transcript_path: str,
+    session_id: str,
+    reason: str,
+    confirmed_by: str,
+    event_label: str,
+    fail_on_copy_error: bool,
+) -> _TranscriptCaptureResult:
+    """Copy a transcript into artifacts and reconcile the manifest."""
+    project_root = resolve_forge_root(cwd)
+    paths = get_artifact_paths(project_root, manifest.name)
+
+    src = Path(transcript_path)
+    dst_abs = paths.transcripts_abs / f"{session_id}.jsonl"
+    dst_rel = paths.transcripts_rel / f"{session_id}.jsonl"
+
+    try:
+        copied = safe_copy_file(src, dst_abs, overwrite=True)
+    except Exception:
+        if fail_on_copy_error:
+            raise
+        copied = False
+
+    if dst_abs.is_file():
+        _copy_transcript_to_pending_runs(dst_abs, session_id=session_id)
+
+    manifest_updated = True
+    manifest_error: str | None = None
+
+    try:
+
+        def _mutate(m: object) -> None:
+            from forge.session.models import SessionState
+
+            if not isinstance(m, SessionState):
+                raise TypeError(f"Expected SessionState, got {type(m)}")
+
+            artifacts = m.confirmed.artifacts
+            _append_artifact_entry(
+                artifacts,
+                kind="transcripts",
+                entry={
+                    "captured_at": now_iso(),
+                    "reason": reason,
+                    "source_path": transcript_path,
+                    "session_id": session_id,
+                    "copied_path": str(dst_rel),
+                    "copied": copied,
+                },
+            )
+
+            m.confirmed.claude_session_id = session_id
+            m.confirmed.transcript_path = transcript_path
+
+            from forge import __version__
+            from forge.session.models import PolicyConfirmed
+
+            if m.confirmed.policy:
+                m.confirmed.policy.forge_version = __version__
+            else:
+                m.confirmed.policy = PolicyConfirmed(forge_version=__version__)
+
+            m.confirmed.confirmed_at = now_iso()
+            m.confirmed.confirmed_by = confirmed_by
+
+        store.update(timeout_s=HOOK_LOCK_TIMEOUT_S, mutate=_mutate)
+        try:
+            from forge.session.index import IndexStore
+
+            IndexStore().update_uuid(manifest.name, session_id, forge_root=str(store.forge_root))
+        except Exception:
+            logger.debug("%s hook: index UUID sync failed", event_label, exc_info=True)
+
+    except FileLockTimeoutError:
+        manifest_updated = False
+        manifest_error = "lock_contended"
+
+    except Exception as e:
+        manifest_updated = False
+        manifest_error = str(e)
+
+    return _TranscriptCaptureResult(
+        copied=copied,
+        dst_abs=dst_abs,
+        dst_rel=dst_rel,
+        manifest_updated=manifest_updated,
+        manifest_error=manifest_error,
+    )
+
+
 @hooks.command(name="session-start")
 @click.option(
     "--cwd",
@@ -397,85 +500,31 @@ def stop() -> None:
         _output_json({"success": False, "error": "missing_session_id"})
         return
 
-    project_root = resolve_forge_root(cwd)
-    paths = get_artifact_paths(project_root, manifest.name)
-
-    src = Path(transcript_path)
-    dst_abs = paths.transcripts_abs / f"{session_id}.jsonl"
-    dst_rel = paths.transcripts_rel / f"{session_id}.jsonl"
-
     try:
         # Claude can invoke Stop repeatedly for the same session UUID as the
         # transcript grows turn by turn. Refresh the UUID-named artifact so
         # search/index consumers see the latest snapshot instead of the first
         # turn that happened to be copied.
-        copied = safe_copy_file(src, dst_abs, overwrite=True)
+        capture = _capture_transcript_artifact(
+            cwd=cwd,
+            store=store,
+            manifest=manifest,
+            transcript_path=transcript_path,
+            session_id=session_id,
+            reason="stop",
+            confirmed_by="hook:stop",
+            event_label="Stop",
+            fail_on_copy_error=True,
+        )
     except Exception as e:
         _output_json({"success": False, "error": "copy_failed", "message": str(e)})
         return
 
-    # Copy transcript to pending run directories (QA/walkthrough artifacts)
-    _copy_transcript_to_pending_runs(dst_abs, session_id=session_id)
-
-    # Track manifest update outcome (but don't return early - we still want to enqueue)
-    manifest_updated = True
-    manifest_error: str | None = None
-
-    try:
-
-        def _mutate(m: object) -> None:
-            from forge.session.models import SessionState
-
-            if not isinstance(m, SessionState):
-                raise TypeError(f"Expected SessionState, got {type(m)}")
-
-            artifacts = m.confirmed.artifacts
-            _append_artifact_entry(
-                artifacts,
-                kind="transcripts",
-                entry={
-                    "captured_at": now_iso(),
-                    "reason": "stop",
-                    "source_path": transcript_path,
-                    "session_id": session_id,
-                    "copied_path": str(dst_rel),
-                    "copied": copied,
-                },
-            )
-
-            # Stop carries the live conversation identity. SessionStart can
-            # lag or report an inherited UUID for native fork launches, so
-            # reconcile from Stop before later cleanup/resume code reads it.
-            m.confirmed.claude_session_id = session_id
-            m.confirmed.transcript_path = transcript_path
-
-            # Record policy provenance (always on Stop, per design §4.1.6)
-            from forge import __version__
-            from forge.session.models import PolicyConfirmed
-
-            if m.confirmed.policy:
-                m.confirmed.policy.forge_version = __version__
-            else:
-                m.confirmed.policy = PolicyConfirmed(forge_version=__version__)
-
-            m.confirmed.confirmed_at = now_iso()
-            m.confirmed.confirmed_by = "hook:stop"
-
-        store.update(timeout_s=HOOK_LOCK_TIMEOUT_S, mutate=_mutate)
-        try:
-            from forge.session.index import IndexStore
-
-            IndexStore().update_uuid(manifest.name, session_id, forge_root=str(store.forge_root))
-        except Exception:
-            logger.debug("Stop hook: index UUID sync failed", exc_info=True)
-
-    except FileLockTimeoutError:
-        manifest_updated = False
-        manifest_error = "lock_contended"
-
-    except Exception as e:
-        manifest_updated = False
-        manifest_error = str(e)
+    copied = capture.copied
+    dst_abs = capture.dst_abs
+    dst_rel = capture.dst_rel
+    manifest_updated = capture.manifest_updated
+    manifest_error = capture.manifest_error
 
     # Run verification check (Ralph-Wiggum pattern)
     # This must happen AFTER transcript copy so we have the artifact to check
@@ -658,75 +707,22 @@ def stop_failure() -> None:
         _output_json({"success": True, "action": "skip", "reason": "no_session_id"})
         return
 
-    project_root = resolve_forge_root(cwd)
-    paths = get_artifact_paths(project_root, manifest.name)
-
-    src = Path(transcript_path)
-    dst_abs = paths.transcripts_abs / f"{session_id}.jsonl"
-    dst_rel = paths.transcripts_rel / f"{session_id}.jsonl"
-
-    try:
-        # Keep the session artifact aligned with the latest transcript snapshot
-        # here too; StopFailure can arrive after earlier Stop captures.
-        copied = safe_copy_file(src, dst_abs, overwrite=True)
-    except Exception:
-        copied = False
-
-    # Only fan out and enqueue if the artifact actually exists on disk.
-    # Otherwise we'd consume pending-transcript markers and create index
-    # markers that retry until poison handling kicks in.
-    if dst_abs.is_file():
-        _copy_transcript_to_pending_runs(dst_abs, session_id=session_id)
-
-    # Best-effort manifest update
-    try:
-
-        def _mutate(m: object) -> None:
-            from forge.session.models import SessionState
-
-            if not isinstance(m, SessionState):
-                raise TypeError(f"Expected SessionState, got {type(m)}")
-
-            artifacts = m.confirmed.artifacts
-            _append_artifact_entry(
-                artifacts,
-                kind="transcripts",
-                entry={
-                    "captured_at": now_iso(),
-                    "reason": "stop-failure",
-                    "source_path": transcript_path,
-                    "session_id": session_id,
-                    "copied_path": str(dst_rel),
-                    "copied": copied,
-                },
-            )
-
-            # StopFailure is a last-chance transcript capture. If it carries a
-            # newer Claude session ID than SessionStart recorded, reconcile the
-            # manifest the same way Stop does.
-            m.confirmed.claude_session_id = session_id
-            m.confirmed.transcript_path = transcript_path
-
-            from forge import __version__
-            from forge.session.models import PolicyConfirmed
-
-            if m.confirmed.policy:
-                m.confirmed.policy.forge_version = __version__
-            else:
-                m.confirmed.policy = PolicyConfirmed(forge_version=__version__)
-
-            m.confirmed.confirmed_at = now_iso()
-            m.confirmed.confirmed_by = "hook:stop-failure"
-
-        store.update(timeout_s=HOOK_LOCK_TIMEOUT_S, mutate=_mutate)
-        try:
-            from forge.session.index import IndexStore
-
-            IndexStore().update_uuid(manifest.name, session_id, forge_root=str(store.forge_root))
-        except Exception:
-            logger.debug("StopFailure hook: index UUID sync failed", exc_info=True)
-    except Exception:
-        pass  # Best-effort: never fail on StopFailure
+    # Keep the session artifact aligned with the latest transcript snapshot
+    # here too; StopFailure can arrive after earlier Stop captures.
+    capture = _capture_transcript_artifact(
+        cwd=cwd,
+        store=store,
+        manifest=manifest,
+        transcript_path=transcript_path,
+        session_id=session_id,
+        reason="stop-failure",
+        confirmed_by="hook:stop-failure",
+        event_label="StopFailure",
+        fail_on_copy_error=False,
+    )
+    copied = capture.copied
+    dst_abs = capture.dst_abs
+    dst_rel = capture.dst_rel
 
     # Only enqueue work markers if the artifact exists on disk.
     # Enqueuing for a nonexistent artifact wastes retries until poison handling.
@@ -1719,17 +1715,11 @@ def _copy_transcript_to_pending_runs(transcript_path: Path, *, session_id: str |
 # --- Team Hook Handlers ---
 
 
-@hooks.command(name="teammate-idle")
-def teammate_idle() -> None:
-    """Handle TeammateIdle hook from Claude Code.
-
-    Exit 0: allow teammate to go idle.
-    Exit 2: teammate continues working (stderr = feedback).
-    """
-    data, err = _read_stdin_json()
+def _team_supervisor_hook(log_label: str, handler: Callable[..., tuple[int, str]]) -> None:
+    data, _err = _read_stdin_json()
     if data is None:
         sys.exit(0)
-    logger.debug("teammate-idle: session=%s", str(data.get("session_id", "?"))[:12])
+    logger.debug("%s: session=%s", log_label, str(data.get("session_id", "?"))[:12])
 
     try:
         cwd = Path.cwd().resolve()
@@ -1746,10 +1736,7 @@ def teammate_idle() -> None:
         sys.exit(0)
 
     from forge.cli.consumer_lane_freeze import persist_lane_freeze
-    from forge.policy.team.handlers import (
-        TEAM_SUPERVISOR_CONSUMER,
-        handle_teammate_idle,
-    )
+    from forge.policy.team.handlers import TEAM_SUPERVISOR_CONSUMER
     from forge.session.consumer_lanes import read_bound_backend_id, read_bound_lane
 
     dispatched_lane = read_bound_lane(manifest, TEAM_SUPERVISOR_CONSUMER)
@@ -1763,13 +1750,25 @@ def teammate_idle() -> None:
     cache_key = _safe_cache_key(data.get("session_id"))
     exit_code, feedback = _run_team_handler(
         cache_key,
-        lambda cache: handle_teammate_idle(data, config, cache, backend_id=backend_id, on_dispatch=_freeze),
+        lambda cache: handler(data, config, cache, backend_id=backend_id, on_dispatch=_freeze),
     )
     if exit_code == 2 and feedback:
         print(feedback, file=sys.stderr)
     sys.exit(exit_code)
 
 
+@hooks.command(name="teammate-idle")
+def teammate_idle() -> None:
+    """Handle TeammateIdle hook from Claude Code.
+
+    Exit 0: allow teammate to go idle.
+    Exit 2: teammate continues working (stderr = feedback).
+    """
+    from forge.policy.team.handlers import handle_teammate_idle
+
+    _team_supervisor_hook("teammate-idle", handle_teammate_idle)
+
+
 @hooks.command(name="task-completed")
 def task_completed() -> None:
     """Handle TaskCompleted hook from Claude Code.
@@ -1777,48 +1776,9 @@ def task_completed() -> None:
     Exit 0: task marked as completed.
     Exit 2: task stays open (stderr = feedback to teammate).
     """
-    data, err = _read_stdin_json()
-    if data is None:
-        sys.exit(0)
-    logger.debug("task-completed: session=%s", str(data.get("session_id", "?"))[:12])
-
-    try:
-        cwd = Path.cwd().resolve()
-        store = resolve_session_store(cwd, session_id=data.get("session_id"))
-        if store is None:
-            sys.exit(0)
-        manifest = store.read()
-        effective = compute_effective_intent(manifest)
-    except Exception:
-        sys.exit(0)
-
-    config = effective.policy.team_supervisor if effective.policy else None
-    if not config or not config.enabled:
-        sys.exit(0)
-
-    from forge.cli.consumer_lane_freeze import persist_lane_freeze
-    from forge.policy.team.handlers import (
-        TEAM_SUPERVISOR_CONSUMER,
-        handle_task_completed,
-    )
-    from forge.session.consumer_lanes import read_bound_backend_id, read_bound_lane
+    from forge.policy.team.handlers import handle_task_completed
 
-    dispatched_lane = read_bound_lane(manifest, TEAM_SUPERVISOR_CONSUMER)
-    backend_id = read_bound_backend_id(manifest, TEAM_SUPERVISOR_CONSUMER)
-
-    def _freeze() -> None:
-        # Fires from _run_supervisor's on_dispatch, so the lane freezes only on a real dispatch
-        # (not a cache/tagger/depth skip). Short HOOK_LOCK_TIMEOUT_S keeps the hook responsive (T6a).
-        persist_lane_freeze(store, TEAM_SUPERVISOR_CONSUMER, dispatched_lane, timeout_s=HOOK_LOCK_TIMEOUT_S)
-
-    cache_key = _safe_cache_key(data.get("session_id"))
-    exit_code, feedback = _run_team_handler(
-        cache_key,
-        lambda cache: handle_task_completed(data, config, cache, backend_id=backend_id, on_dispatch=_freeze),
-    )
-    if exit_code == 2 and feedback:
-        print(feedback, file=sys.stderr)
-    sys.exit(exit_code)
+    _team_supervisor_hook("task-completed", handle_task_completed)
 
 
 @hooks.command(name="read-hygiene")