multi-forge 0.9.0__tar.gz → 0.9.1__tar.gz

{multi_forge-0.9.0 → multi_forge-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-forge
-Version: 0.9.0
+Version: 0.9.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

{multi_forge-0.9.0 → multi_forge-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "multi-forge"
-version = "0.9.0"
+version = "0.9.1"
 description = "Multi-runtime agent toolkit: proxy routing, cost control, session management, policy enforcement, and workflow orchestration"
 readme = "README.md"
 license = "Apache-2.0"
@@ -124,6 +124,7 @@ constraint-dependencies = [
     "virtualenv>=20.36.1",
     "aiohttp>=3.14.1",
     "cryptography>=48.0.1",
+    "mcp>=1.28.1",
     "python-multipart>=0.0.31",
     "Pygments>=2.20.0",
     "PyJWT>=2.13.0",

{multi_forge-0.9.0 → multi_forge-0.9.1}/src/forge/cli/extensions.py

@@ -43,17 +43,20 @@ from forge.install.installer import (
     Installer,
     find_claude_root,
     find_forge_installation,
+    get_extensions_root,
     inspect_skill_package_status,
 )
 from forge.install.models import (
     FILE_MODULES,
     PROFILE_RANK,
+    InstalledManifest,
     InstallMode,
     InstallModule,
     InstallPlan,
     InstallProfile,
     InstallScope,
     get_gated_skills,
+    parse_installation_key,
 )
 from forge.install.project_compat import (
     ProjectCompatibilityError,
@@ -61,7 +64,13 @@ from forge.install.project_compat import (
     format_project_compatibility_recovery,
 )
 from forge.install.project_registry import EnrollmentSource, ProjectRegistryStore
+from forge.install.skill_compiler import discover_skill_source_names
 from forge.install.tracking import TrackingStore
+from forge.install.unmanaged import (
+    runtime_skill_scan_roots,
+    scan_unmanaged_skill_state,
+)
+from forge.session.claude.paths import get_claude_home
 
 console = Console()
 _log = logging.getLogger(__name__)
@@ -561,6 +570,11 @@ def _print_plan(plan: InstallPlan, dry_run: bool = False) -> None:
                 style=style,
             )
         console.print(table)
+        for package in plan.skill_packages:
+            if package.recovery:
+                console.print(
+                    f"  [yellow]{package.runtime}/{package.skill} recovery:[/yellow] {escape(package.recovery)}"
+                )
 
     if plan.files:
         console.print(f"\n{prefix}[bold]Files:[/bold]")
@@ -726,14 +740,21 @@ def _can_resolve_project_root(scope: InstallScope, *, anchor: Path | None = None
         return False
 
 
-def _resolve_status_project_root(scope: InstallScope, anchor: Path | None) -> Path | None:
+def _resolve_status_project_root(
+    scope: InstallScope,
+    anchor: Path | None,
+    tracking_snapshot: InstalledManifest | None = None,
+) -> Path | None:
     """Resolve a status lookup root, including tracked installs without ``.claude``."""
 
     try:
         return _resolve_project_root(scope, anchor=anchor)
     except NoClaudeDirectoryError:
         try:
-            detected_scope, detected_root = find_forge_installation(start=anchor)
+            detected_scope, detected_root = find_forge_installation(
+                start=anchor,
+                tracking_snapshot=tracking_snapshot,
+            )
         except NoForgeInstallationError:
             return None
         return detected_root if detected_scope == scope else None
@@ -1346,7 +1367,10 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
     # A corrupt installed.json raises TrackingCorruptedError (a StateCorruptedError);
     # it propagates to the top-level handler for the uniform reset tip.
     tracking = TrackingStore()
-    tracked_installations = tracking.list_installations()
+    manifest = tracking.read()
+    tracked_installations = [
+        (*parse_installation_key(key), installation) for key, installation in manifest.installations.items()
+    ]
     installations_by_target = {
         (tracked_scope, project_path): installation
         for tracked_scope, project_path, installation in tracked_installations
@@ -1363,7 +1387,7 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
         scopes = [InstallScope.USER, InstallScope.PROJECT, InstallScope.LOCAL]
     elif scope is None and anchor is None:
         try:
-            detected_scope, detected_root = find_forge_installation()
+            detected_scope, detected_root = find_forge_installation(tracking_snapshot=manifest)
             detected_scope_name = detected_scope.value
             scopes = [detected_scope]
         except NoForgeInstallationError:
@@ -1371,7 +1395,10 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
     elif scope is None and anchor is not None:
         # --root without --scope: auto-detect scope at that path
         try:
-            detected_scope, detected_root = find_forge_installation(start=anchor)
+            detected_scope, detected_root = find_forge_installation(
+                start=anchor,
+                tracking_snapshot=manifest,
+            )
             detected_scope_name = detected_scope.value
             scopes = [detected_scope]
         except NoForgeInstallationError:
@@ -1382,12 +1409,59 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
     # Use the detected root (from walk-up) over the raw anchor for lookups.
     effective_anchor = detected_root if detected_root is not None else anchor
 
+    scope_contexts = [
+        (
+            selected_scope,
+            _resolve_status_project_root(
+                selected_scope,
+                effective_anchor,
+                tracking_snapshot=manifest,
+            ),
+        )
+        for selected_scope in scopes
+    ]
+    non_user_scopes = [selected_scope for selected_scope in scopes if selected_scope != InstallScope.USER]
+    shared_scan_root = next(
+        (
+            project_root
+            for selected_scope, project_root in scope_contexts
+            if selected_scope != InstallScope.USER and project_root
+        ),
+        None,
+    )
+    scanner_scope_roots: list[tuple[InstallScope, Path | None]] = []
+    for selected_scope, project_root in scope_contexts:
+        if selected_scope == InstallScope.USER:
+            scanner_scope_roots.append((selected_scope, None))
+        elif project_root is not None:
+            scanner_scope_roots.append((selected_scope, project_root))
+        elif len(non_user_scopes) > 1 and shared_scan_root is not None:
+            # `--all` scans both logical Claude scopes at the effective root
+            # even when only one scope has a tracking/sidecar signal.
+            scanner_scope_roots.append((selected_scope, shared_scan_root))
+    try:
+        current_skill_names = discover_skill_source_names(get_extensions_root() / InstallModule.SKILLS.value)
+    except (OSError, ValueError) as exc:
+        _log.warning("extension status: current skill names unavailable; using historical names only: %s", exc)
+        current_skill_names = ()
+    scan_roots = runtime_skill_scan_roots(
+        scanner_scope_roots,
+        user_home=Path.home(),
+        claude_home=get_claude_home(),
+    )
+    unmanaged_scan = scan_unmanaged_skill_state(
+        scan_roots,
+        current_skill_names=current_skill_names,
+        tracking=manifest,
+    )
+    unmanaged_packages = unmanaged_scan.packages
+    unmanaged_root_issues = unmanaged_scan.root_issues
+
     if as_json:
         import json
 
-        data = []
-        for s in scopes:
-            project_root = _resolve_status_project_root(s, effective_anchor)
+        installations = []
+        for s, project_root in scope_contexts:
             project_path_str = str(project_root) if project_root else None
 
             inst = installations_by_target.get((s.value, project_path_str))
@@ -1399,7 +1473,7 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
                 project_root,
                 tracked_installations=tracked_installations,
             )
-            data.append(
+            installations.append(
                 {
                     "scope": s.value,
                     "profile": inst.profile,
@@ -1427,7 +1501,17 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
                     "updated_at": inst.updated_at,
                 }
             )
-        click.echo(json.dumps(data, indent=2, default=str))
+        click.echo(
+            json.dumps(
+                {
+                    "schema_version": 2,
+                    "installations": installations,
+                    "unmanaged_skill_packages": [package.to_dict() for package in unmanaged_packages],
+                },
+                indent=2,
+                default=str,
+            )
+        )
         return
 
     if detected_scope_name:
@@ -1437,8 +1521,7 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
         console.print(f"[dim]No extensions detected in {location}[/dim]")
         console.print("[dim]Showing all scopes for this location:[/dim]")
 
-    for s in scopes:
-        project_root = _resolve_status_project_root(s, effective_anchor)
+    for s, project_root in scope_contexts:
         project_path_str = str(project_root) if project_root else None
 
         installation = installations_by_target.get((s.value, project_path_str))
@@ -1526,20 +1609,51 @@ def status_cmd(scope: str | None, path: str | None, show_all: bool, as_json: boo
             for f in installation.files:
                 console.print(f"    - {display_path(f.target_path)}")
 
+    console.print("\n[bold]Unmanaged runtime skill packages[/bold]")
+    if not unmanaged_packages and not unmanaged_root_issues:
+        console.print("  [dim]None found in the selected runtime roots.[/dim]")
+    elif unmanaged_packages:
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 1))
+        table.add_column("RUNTIME")
+        table.add_column("SKILL")
+        table.add_column("SHAPE")
+        table.add_column("PROVENANCE")
+        table.add_column("TARGET")
+        table.add_column("CLEANUP")
+        for package in unmanaged_packages:
+            table.add_row(
+                package.runtime,
+                package.skill,
+                package.shape,
+                package.provenance,
+                display_path(package.target_dir),
+                package.cleanup_scope or "report only",
+                style="yellow" if package.cleanup_eligible else "red",
+            )
+        console.print(table)
+        for package in unmanaged_packages:
+            if package.collision_dirs:
+                console.print(
+                    f"  [red]{package.runtime}/{package.skill} collisions:[/red] "
+                    + ", ".join(display_path(path) for path in package.collision_dirs)
+                )
+            console.print(f"  [dim]{package.runtime}/{package.skill}:[/dim] {package.cleanup_reason}")
+            if package.recovery:
+                console.print(f"  [yellow]{package.runtime}/{package.skill}:[/yellow] {package.recovery}")
+    for issue in unmanaged_root_issues:
+        console.print(
+            f"  [red]Root not scanned:[/red] {display_path(issue.root_dir)} " f"({issue.runtime}): {issue.reason}"
+        )
+
     if scope is None and not show_all and anchor is None:
         local_installed = any(
-            tracking.get_installation(
-                s.value,
-                str(_resolve_project_root(s)) if s != InstallScope.USER else None,
-            )
-            for s in scopes
-            if s == InstallScope.USER or _can_resolve_project_root(s)
+            (selected_scope.value, str(project_root) if project_root is not None else None) in installations_by_target
+            for selected_scope, project_root in scope_contexts
         )
         if not local_installed:
-            all_installations = tracking.list_installations()
-            if all_installations:
+            if tracked_installations:
                 print_tip(
-                    f"{len(all_installations)} installation(s) exist elsewhere. Run 'forge info' to see all.",
+                    f"{len(tracked_installations)} installation(s) exist elsewhere. Run 'forge info' to see all.",
                     console=console,
                 )
             else:

{multi_forge-0.9.0 → multi_forge-0.9.1}/src/forge/cli/gc.py

@@ -208,5 +208,6 @@ def _category_label(category: str) -> str:
         "search_docs": "Orphan search docs:",
         "dead_installations": "Dead installations:",
         "corrupt_state": "Corrupt state files:",
+        "unmanaged_skill_packages": "Unmanaged skill packages:",
     }
     return labels.get(category, f"{category}:")

{multi_forge-0.9.0 → multi_forge-0.9.1}/src/forge/cli/workflow.py

@@ -87,11 +87,12 @@ def _run_preflight(
     *,
     as_json: bool = False,
     routing_plan: Any | None = None,
+    resume_id: str | None = None,
 ) -> None:
     """Check resolved routing/auth before spawning workers. Exit 1 on failure."""
     from forge.review.engine import preflight_check
 
-    errors = preflight_check(specs, routing_plan=routing_plan)
+    errors = preflight_check(specs, routing_plan=routing_plan, resume_id=resume_id)
     warnings = _routing_plan_warnings(specs, routing_plan)
     if not errors:
         if not as_json:
@@ -107,12 +108,17 @@ def _run_preflight(
         print_error("Workflow preflight failed:")
         for err in errors:
             console.print(f"  - {err}")
+        runtime_tips: list[str] = []
+        if any(spec.runtime == "claude_code" for spec in specs):
+            runtime_tips.append("Run 'command -v claude' to check the Claude worker runtime.")
+        if any(spec.runtime == "codex" for spec in specs):
+            runtime_tips.append("Run 'forge runtime preflight codex' to refresh Codex readiness.")
         print_tip(
             "Run 'forge workflow list-models' to check model availability.",
             "Run 'forge proxy list' to check proxy status.",
             "Run 'forge auth status' to check auth status.",
             "Run 'forge proxy create <template>' to create a proxy.",
-            "Run 'command -v claude' to check worker runtime.",
+            *runtime_tips,
             console=console,
         )
     sys.exit(1)
@@ -151,16 +157,20 @@ def _resolved_models_summary(
     summary: dict[str, dict[str, Any]] = {}
     for idx, (spec, result) in enumerate(zip(specs, routing_plan.routes)):
         route = result.route
+        runtime_native = result.source == "runtime_native"
         worker_id = worker_ids[idx] if worker_ids and idx < len(worker_ids) else spec.effective_worker_id
         entry: dict[str, Any] = {
             "requested_model": spec.name,
             "model_id": spec.model_id,
             "resolved_model": route.model_ref if route else None,
-            "provider": route.provider if route else None,
+            "provider": "openai" if runtime_native else (route.provider if route else None),
+            "runtime": spec.runtime,
             "source": result.source,
             "proxy": result.proxy_id,
             "template": result.template or (route.template_id if route else None),
         }
+        if runtime_native:
+            entry["model_selection"] = "runtime_default"
         if roles and worker_id in roles:
             entry[role_field] = roles[worker_id]
         if result.warning:
@@ -176,8 +186,13 @@ def _format_resolved_models(summary: dict[str, dict[str, Any]]) -> str:
 
     lines = ["Resolved models:"]
     for worker_id, item in summary.items():
-        resolved = item.get("resolved_model") or "(unresolved)"
+        resolved = (
+            "(runtime default)"
+            if item.get("model_selection") == "runtime_default"
+            else item.get("resolved_model") or "(unresolved)"
+        )
         provider = item.get("provider") or "unknown"
+        runtime = item.get("runtime") or "unknown"
         proxy = item.get("proxy") or "(direct)"
         template = item.get("template") or "(direct)"
         requested = item.get("requested_model") or worker_id
@@ -185,7 +200,7 @@ def _format_resolved_models(summary: dict[str, dict[str, Any]]) -> str:
         stance = f", stance={item['stance']}" if item.get("stance") else ""
         lines.append(
             f"- {worker_id}: requested={requested}, resolved={resolved}, "
-            f"provider={provider}, proxy={proxy}, template={template}{role}{stance}"
+            f"provider={provider}, runtime={runtime}, proxy={proxy}, template={template}{role}{stance}"
         )
     return "\n".join(lines) + "\n\n"
 
@@ -238,10 +253,10 @@ def workflow_cmd() -> None:
     "--available",
     "available_only",
     is_flag=True,
-    help="Show only ready models (credentials configured and routing usable)",
+    help="Show only ready workers (runtime prerequisites and routing usable)",
 )
 def list_models(as_json: bool, available_only: bool) -> None:
-    """Show workflow model readiness."""
+    """Show workflow worker readiness."""
     from forge.review.models import available_model_specs, check_model_availability
 
     availabilities = check_model_availability(available_model_specs())
@@ -255,6 +270,7 @@ def list_models(as_json: bool, available_only: bool) -> None:
                 "name": a.spec.name,
                 "model_id": a.spec.model_id,
                 "family": a.spec.family,
+                "runtime": a.spec.runtime,
                 "provider_refs": list(a.spec.provider_refs),
                 "preferred_proxy": a.spec.preferred_proxy,
                 "description": a.spec.description,
@@ -284,6 +300,9 @@ def _primary_credential(spec: ModelSpec) -> str:
     Uses derive_model_routes() to get the first route's credential,
     which is stable and deterministic (no registry read).
     """
+    if spec.runtime == "codex":
+        return "runtime-native"
+
     from forge.review.routing import derive_model_routes
 
     routes = derive_model_routes(spec)
@@ -328,11 +347,14 @@ def _print_grouped_models(availabilities: list) -> None:
     console.print("\n[bold]Available Models[/bold]\n")
 
     for cred_name, items in groups.items():
-        env_var = _credential_env_var(cred_name)
-        configured = _credential_configured(cred_name)
-        config_tag = "[green]configured[/green]" if configured else "[yellow]not configured[/yellow]"
-        env_display = f" ({env_var})" if env_var else ""
-        console.print(f"  [bold]{cred_name}[/bold]{env_display}  [{config_tag}]")
+        if cred_name == "runtime-native":
+            console.print("  [bold]runtime-native[/bold]  [[green]runtime preflight[/green]]")
+        else:
+            env_var = _credential_env_var(cred_name)
+            configured = _credential_configured(cred_name)
+            config_tag = "[green]configured[/green]" if configured else "[yellow]not configured[/yellow]"
+            env_display = f" ({env_var})" if env_var else ""
+            console.print(f"  [bold]{cred_name}[/bold]{env_display}  [{config_tag}]")
 
         for a in items:
             style = _STATUS_STYLES.get(a.status, "")
@@ -364,7 +386,7 @@ def _print_grouped_models(availabilities: list) -> None:
     "-m",
     type=str,
     default=None,
-    help="Comma-separated model names (default: all)",
+    help="Comma-separated worker names across Claude/Codex runtimes (default: workflow quorum)",
 )
 @click.option("--timeout", "-t", type=int, default=600, help="Per-model timeout in seconds")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
@@ -405,7 +427,7 @@ def _print_grouped_models(availabilities: list) -> None:
     "effort",
     type=click.Choice(list(CLAUDE_EFFORT_LEVELS)),
     default=None,
-    help="Per-worker reasoning effort (claude --effort: low/medium/high/xhigh/max)",
+    help="Claude workers only: reasoning effort (low/medium/high/xhigh/max)",
 )
 @click.pass_context
 def panel(
@@ -510,7 +532,7 @@ def panel(
         _handle_routing_error(e, as_json=as_json)
         return
 
-    _run_preflight(specs, as_json=as_json, routing_plan=routing_plan)
+    _run_preflight(specs, as_json=as_json, routing_plan=routing_plan, resume_id=resume_id)
 
     from forge.core.invoker import Attribution
 
@@ -831,7 +853,7 @@ def _handle_review_output(
     "-m",
     type=str,
     default="claude-opus",
-    help="Comma-separated model names (default: claude-opus)",
+    help="Comma-separated worker names across Claude/Codex runtimes (default: claude-opus)",
 )
 @click.option("--timeout", "-t", type=int, default=600, help="Per-model timeout in seconds")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
@@ -854,7 +876,7 @@ def _handle_review_output(
     "effort",
     type=click.Choice(list(CLAUDE_EFFORT_LEVELS)),
     default=None,
-    help="Per-worker reasoning effort (claude --effort: low/medium/high/xhigh/max)",
+    help="Claude workers only: reasoning effort (low/medium/high/xhigh/max)",
 )
 @click.pass_context
 def analyze(
@@ -1036,7 +1058,7 @@ def _resolve_debate_prompt(
     "-m",
     type=str,
     default=None,
-    help="Comma-separated model names (default: all)",
+    help="Comma-separated worker names across Claude/Codex runtimes (default: workflow quorum)",
 )
 @click.option("--timeout", "-t", type=int, default=600, help="Per-model timeout in seconds")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
@@ -1066,7 +1088,7 @@ def _resolve_debate_prompt(
     "effort",
     type=click.Choice(list(CLAUDE_EFFORT_LEVELS)),
     default=None,
-    help="Per-worker reasoning effort (claude --effort: low/medium/high/xhigh/max)",
+    help="Claude workers only: reasoning effort (low/medium/high/xhigh/max)",
 )
 @click.pass_context
 def debate(
@@ -1567,7 +1589,7 @@ def _print_consensus_text(output: ConsensusOutput, resolved_models: dict[str, di
     "-m",
     type=str,
     default=None,
-    help="Comma-separated model names (default: all)",
+    help="Comma-separated worker names across Claude/Codex runtimes (default: workflow quorum)",
 )
 @click.option(
     "--timeout",
@@ -1603,7 +1625,7 @@ def _print_consensus_text(output: ConsensusOutput, resolved_models: dict[str, di
     "effort",
     type=click.Choice(list(CLAUDE_EFFORT_LEVELS)),
     default=None,
-    help="Per-worker reasoning effort (claude --effort: low/medium/high/xhigh/max)",
+    help="Claude workers only: reasoning effort (low/medium/high/xhigh/max)",
 )
 @click.pass_context
 def consensus(

{multi_forge-0.9.0 → multi_forge-0.9.1}/src/forge/core/invoker/__init__.py

@@ -8,6 +8,7 @@ ordered fan-out, timeouts) and per-job usage emission. Phase 5 adds a
 
 from .claude import ClaudeHeadlessInvoker
 from .codex import CodexHeadlessInvoker, prepare_codex_request
+from ._lifecycle import run_grouped_parallel
 from .types import (
     Attribution,
     HeadlessInvoker,
@@ -23,4 +24,5 @@ __all__ = [
     "HeadlessRequest",
     "HeadlessResult",
     "prepare_codex_request",
+    "run_grouped_parallel",
 ]