forge-autonomy 2.3.1__tar.gz → 2.3.2__tar.gz

{forge_autonomy-2.3.1/forge_autonomy.egg-info → forge_autonomy-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.3.1
+Version: 2.3.2
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0

forge_autonomy-2.3.2/forge/__main__.py

@@ -0,0 +1,63 @@
+"""Read-only command entrypoint for the packaged Forge runtime."""
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+
+from ._version import canonical_version
+from .runtime.data_root import DataRootResolver
+
+
+def _status(data_root: str | None) -> dict[str, object]:
+    """Read only the operator-safe instance projection; never initialise it."""
+    root = DataRootResolver(cli_data_root=data_root).resolve()
+    database = root / "forge.db"
+    marker = root / "instance" / "runtime-instance.json"
+    result: dict[str, object] = {"product_version": canonical_version(), "data_root": str(root),
+                                 "initialized": marker.is_file() and database.is_file(),
+                                 "runtime_status": "uninitialized", "execution_host_peer": "not_configured"}
+    if not result["initialized"]:
+        return result
+    try:
+        connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
+        try:
+            metadata = dict(connection.execute("SELECT key, value FROM runtime_metadata"))
+        finally:
+            connection.close()
+    except sqlite3.Error:
+        result["runtime_status"] = "unavailable"
+        return result
+    result.update({"instance_id": metadata.get("runtime_id"), "storage_schema": metadata.get("schema_version"),
+                   "runtime_status": metadata.get("status", "unavailable")})
+    return result
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="forge",
+        description="Forge mission planning and evidence interpretation runtime.",
+    )
+    parser.add_argument("--version", action="version", version=canonical_version())
+    parser.add_argument("--data-root", help="Forge-owned runtime data root")
+    subparsers = parser.add_subparsers(dest="command")
+    server = subparsers.add_parser("server", help="manage local Forge storage")
+    server_commands = server.add_subparsers(dest="server_command", required=True)
+    server_commands.add_parser("init", help="create and validate the configured Forge data root")
+    server_commands.add_parser("status", help="print read-only runtime status as JSON")
+    subparsers.add_parser("status", help="print read-only runtime status as JSON")
+    args = parser.parse_args(argv)
+    if args.command == "server" and args.server_command == "init":
+        from .runtime import RuntimeBootstrap
+        database = RuntimeBootstrap(data_root=args.data_root, forge_version=canonical_version()).open()
+        try:
+            print(json.dumps(_status(args.data_root), sort_keys=True))
+        finally:
+            database.close()
+    elif args.command == "status" or (args.command == "server" and args.server_command == "status"):
+        print(json.dumps(_status(args.data_root), sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{forge_autonomy-2.3.1 → forge_autonomy-2.3.2}/forge/runtime/__init__.py

@@ -23,6 +23,7 @@ from .bootstrap import (
     repository_identity,
     repository_uuid,
 )
+from .data_root import DataRootError, DataRootResolver, RUNTIME_DIRECTORIES
 from .evidence import RuntimeDecisionEvidenceReference, RuntimeEvidence
 from .runner import BootstrapMissionRunner, MissionRunnerError, RuntimePromptFactory
 from .service import ForgeRuntimeService, RuntimeServiceTick
@@ -30,5 +31,5 @@ from .service import ForgeRuntimeService, RuntimeServiceTick
 __all__ = [
     "BootstrapMissionRunner", "MissionRunnerError", "RuntimePromptFactory", "ForgeRuntimeService", "RuntimeServiceTick",
     "RUNTIME_SCHEMA_VERSION", "RuntimeDatabase", "RuntimeDatabaseError", "RuntimeIntegrityError", "RuntimeDecisionEvidenceReference", "RuntimeEvidence",
-    "RUNTIME_INSTANCE_VERSION", "RUNTIME_INITIALIZATION_VERSION", "RuntimeBootstrap", "RuntimeIdentity", "RuntimeInstance", "RuntimeLocation", "RuntimeRecovery", "RuntimeResolutionError", "RuntimeResolver", "repository_identity", "repository_uuid",
+    "RUNTIME_INSTANCE_VERSION", "RUNTIME_INITIALIZATION_VERSION", "RuntimeBootstrap", "RuntimeIdentity", "RuntimeInstance", "RuntimeLocation", "RuntimeRecovery", "RuntimeResolutionError", "RuntimeResolver", "repository_identity", "repository_uuid", "DataRootError", "DataRootResolver", "RUNTIME_DIRECTORIES",
 ]

forge_autonomy-2.3.2/forge/runtime/bootstrap.py

@@ -0,0 +1,263 @@
+"""Persistent Runtime Instance resolution, bootstrap, and recovery.
+
+The Runtime Database is storage owned by a Runtime Instance; it is never the
+identity of that instance. Resolution uses the product-owned data root and
+validates every persisted boundary before SQLite is opened.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+from typing import Any
+
+from .data_root import DataRootResolver, RUNTIME_DIRECTORIES
+
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - supported Forge hosts are POSIX.
+    fcntl = None
+
+
+RUNTIME_INSTANCE_VERSION = "1"
+RUNTIME_INITIALIZATION_VERSION = "1"
+
+
+class RuntimeResolutionError(RuntimeError):
+    """A canonical Runtime Instance cannot be determined safely."""
+
+
+@dataclass(frozen=True)
+class RuntimeIdentity:
+    """The immutable identity of a single Forge Runtime Instance.
+
+    Compatibility properties retain the Runtime Database vocabulary used by
+    earlier callers while the public architectural concept is Runtime Instance.
+    """
+
+    runtime_id: str
+    repository_identity: str
+    repository_root: str
+    instance_version: str
+    initialization_version: str
+    repository_uuid: str | None
+    created_at: str
+    database_location: str
+    last_access_at: str
+    status: str
+
+    @classmethod
+    def from_metadata(cls, metadata: dict[str, str]) -> "RuntimeIdentity":
+        required = ("runtime_id", "repository_identity", "repository_root", "created_at", "initialization_version")
+        if any(not metadata.get(key) for key in required):
+            raise RuntimeResolutionError("runtime identity metadata is incomplete")
+        return cls(metadata["runtime_id"], metadata["repository_identity"], metadata["repository_root"],
+                   metadata.get("instance_version", RUNTIME_INSTANCE_VERSION), metadata["initialization_version"],
+                   metadata.get("repository_uuid") or None, metadata["created_at"],
+                   metadata.get("database_location", ""), metadata.get("last_access_at", ""), metadata.get("status", ""))
+
+    @property
+    def repository_id(self) -> str:
+        return self.repository_identity
+
+    @property
+    def database_version(self) -> str:
+        return self.instance_version
+
+    def to_dict(self) -> dict[str, str]:
+        result = {"runtime_id": self.runtime_id, "repository_identity": self.repository_identity,
+                "repository_id": self.repository_identity, "repository_root": self.repository_root,
+                "instance_version": self.instance_version, "database_version": self.instance_version,
+                "initialization_version": self.initialization_version,
+                "created_at": self.created_at, "database_location": self.database_location,
+                "last_access_at": self.last_access_at, "status": self.status}
+        if self.repository_uuid is not None:
+            result["repository_uuid"] = self.repository_uuid
+        return result
+
+
+@dataclass(frozen=True)
+class RuntimeInstance:
+    """Resolved Runtime Instance: immutable identity plus mutable placement."""
+
+    identity: RuntimeIdentity
+    location: Path
+    last_access_at: str
+    status: str
+
+    def to_dict(self) -> dict[str, str]:
+        result = self.identity.to_dict()
+        result.update({"instance_location": str(self.location), "database_location": str(self.location),
+                       "last_access_at": self.last_access_at, "status": self.status})
+        return result
+
+
+@dataclass(frozen=True)
+class RuntimeLocation:
+    path: Path
+    source: str
+    bootstrap: bool
+
+
+def canonical_repository_root(repository_root: Path | str) -> Path:
+    """Return the common Git checkout root for a main checkout or worktree."""
+    root = Path(repository_root)
+    try:
+        common_dir = subprocess.check_output(
+            ("git", "-C", str(root), "rev-parse", "--path-format=absolute", "--git-common-dir"),
+            text=True, stderr=subprocess.DEVNULL,
+        ).strip()
+    except (OSError, subprocess.CalledProcessError):
+        return root.resolve()
+    return Path(common_dir).resolve().parent
+
+
+def repository_identity(repository_root: Path | str) -> str:
+    """Derive a location-independent identity from the Git root commit.
+
+    The root commit is shared by branches, worktrees, and filesystem moves.
+    A non-Git workspace has no durable Git identity and therefore remains
+    intentionally local to its canonical path.
+    """
+    root = canonical_repository_root(repository_root)
+    try:
+        initial_commit = subprocess.check_output(
+            ("git", "-C", str(root), "rev-list", "--max-parents=0", "HEAD"),
+            text=True, stderr=subprocess.DEVNULL,
+        ).strip().splitlines()
+    except (OSError, subprocess.CalledProcessError):
+        initial_commit = []
+    basis = initial_commit[0] if len(initial_commit) == 1 and initial_commit[0] else str(root.resolve())
+    return "forge-repository-" + hashlib.sha256(basis.encode("utf-8")).hexdigest()[:24]
+
+
+def repository_uuid(repository_root: Path | str) -> str | None:
+    """Return an explicitly configured repository UUID when the host provides one."""
+    try:
+        value = subprocess.check_output(
+            ("git", "-C", str(canonical_repository_root(repository_root)), "config", "--get", "forge.repositoryUUID"),
+            text=True, stderr=subprocess.DEVNULL,
+        ).strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    return value or None
+
+
+class RuntimeResolver:
+    """Resolve one installed Forge instance beneath the product-owned data root.
+
+    ``repository_root`` remains an API-compatibility argument only.  It is not
+    consulted for location, identity, discovery, or writes.
+    """
+
+    def __init__(self, repository_root: Path | str = ".", *, configured_location: Path | str | None = None,
+                 configured_runtime_root: Path | str | None = None, data_root: Path | str | None = None,
+                 environment: dict[str, str] | None = None) -> None:
+        self.repository_root = Path(repository_root).resolve()
+        if configured_location is not None and (configured_runtime_root is not None or data_root is not None):
+            raise RuntimeResolutionError("choose a data root or an explicit database location, not both")
+        explicit_root = data_root if data_root is not None else configured_runtime_root
+        # Supplying a path to the long-standing library API is an explicit
+        # test/embedder root, never an inferred checkout location. Installed
+        # entrypoints use ``data_root`` (or the resolver default) instead.
+        self.compatibility_workspace = explicit_root is None and configured_location is None and repository_root != "."
+        self.data_root = (Path(repository_root).expanduser().resolve() if self.compatibility_workspace
+                          else Path(configured_location).expanduser().resolve().parent if configured_location is not None
+                          else DataRootResolver(cli_data_root=explicit_root, environment=environment).resolve())
+        self.configured_location = None if configured_location is None else Path(configured_location).expanduser().resolve()
+
+    @property
+    def default_location(self) -> Path:
+        return self.data_root / "forge.db"
+
+    @property
+    def instance_marker_path(self) -> Path:
+        return self.data_root / "instance" / "runtime-instance.json"
+
+    @property
+    def initialization_lock_path(self) -> Path:
+        return self.data_root / "locks" / "runtime.lock"
+
+    def resolve(self) -> RuntimeLocation:
+        path = self.configured_location or self.default_location
+        if path.is_file():
+            return RuntimeLocation(path.resolve(), "configured" if self.configured_location else "data_root", False)
+        if self.configured_location is None and self.instance_marker_path.exists():
+            raise RuntimeResolutionError("initialized Forge data root is missing forge.db")
+        return RuntimeLocation(path, "configured" if self.configured_location else "data_root", True)
+
+
+class RuntimeBootstrap:
+    """Discover an existing Runtime Instance or create exactly one new instance."""
+
+    def __init__(self, repository_root: Path | str = ".", *, configured_location: Path | str | None = None,
+                 configured_runtime_root: Path | str | None = None, data_root: Path | str | None = None,
+                 environment: dict[str, str] | None = None, forge_version: str = "0.0") -> None:
+        self.resolver = RuntimeResolver(repository_root, configured_location=configured_location,
+                                        configured_runtime_root=configured_runtime_root, data_root=data_root, environment=environment)
+        self.forge_version = forge_version
+
+    def open(self):
+        from .database import RuntimeDatabase
+        if fcntl is None:
+            raise RuntimeResolutionError("Runtime Instance initialization lock is unavailable")
+        self._create_root_layout()
+        with self.resolver.initialization_lock_path.open("a+", encoding="utf-8") as lock:
+            try:
+                fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError as error:
+                raise RuntimeResolutionError("another mutating Forge runtime owns this data root") from error
+            try:
+                location = self.resolver.resolve()
+                database = RuntimeDatabase(self.resolver.repository_root, path=location.path, forge_version=self.forge_version,
+                                          installation_scoped=not self.resolver.compatibility_workspace)
+                try:
+                    marker = self.resolver.instance_marker_path
+                    temporary = marker.with_suffix(".tmp")
+                    temporary.write_text(database.runtime_identity.runtime_id + "\n", encoding="utf-8")
+                    os.chmod(temporary, 0o600)
+                    os.replace(temporary, marker)
+                except Exception:
+                    database.close()
+                    raise
+                return database
+            finally:
+                fcntl.flock(lock.fileno(), fcntl.LOCK_UN)
+
+    def _create_root_layout(self) -> None:
+        root = self.resolver.data_root
+        root.mkdir(parents=True, exist_ok=True)
+        os.chmod(root, 0o700)
+        for name in RUNTIME_DIRECTORIES:
+            directory = root / name
+            directory.mkdir(exist_ok=True)
+            os.chmod(directory, 0o700)
+
+
+class RuntimeRecovery:
+    """Runtime-only recovery projections; no source or legacy-state reconstruction."""
+
+    def __init__(self, database) -> None:
+        self._database = database
+
+    def recover(self) -> dict[str, Any]:
+        self._database.validate_integrity()
+        connection = self._database._connection
+        documents = lambda table: tuple(json.loads(row[0]) for row in connection.execute(f"SELECT document FROM {table} ORDER BY 1"))
+        receipts = tuple(dict(row) for row in connection.execute(
+            "SELECT receipt_id, mission_id, execution_host, execution_run_id, engineering_report_id, correlation_identity, executed_at, outcome FROM execution_receipts ORDER BY receipt_id"
+        ))
+        planning = None
+        row = connection.execute("SELECT document FROM planning_state WHERE singleton = 1").fetchone()
+        if row is not None:
+            planning = json.loads(row[0])
+        instance = RuntimeInstance(self._database.runtime_identity, self._database.path.resolve(),
+                                   self._database.metadata["last_access_at"], self._database.metadata["status"])
+        return {"runtime_instance": instance.to_dict(), "runtime_identity": instance.identity.to_dict(),
+                "mission_state": documents("mission_state"), "architecture_reviews": documents("architecture_reviews"),
+                "mission_recommendations": documents("mission_recommendations"), "decision_evidence": documents("decision_evidence"),
+                "execution_receipts": receipts, "planning_state": planning, "source": "runtime_instance"}

forge_autonomy-2.3.2/forge/runtime/data_root.py

@@ -0,0 +1,49 @@
+"""Canonical, side-effect-free resolution of Forge-owned runtime storage.
+
+This is deliberately the only place that chooses a writable location for an
+installed Forge runtime.  Resolving a root is a read-only operation; creation
+belongs to :class:`forge.runtime.RuntimeBootstrap`.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import sys
+from typing import Mapping
+
+
+class DataRootError(RuntimeError):
+    """The requested Forge data root is not a safe explicit location."""
+
+
+class DataRootResolver:
+    """Resolve ``--data-root``, ``FORGE_DATA_ROOT``, then the native default."""
+
+    def __init__(self, *, cli_data_root: Path | str | None = None,
+                 environment: Mapping[str, str] | None = None,
+                 platform: str | None = None, home: Path | str | None = None) -> None:
+        self._cli_data_root = cli_data_root
+        self._environment = os.environ if environment is None else environment
+        self._platform = sys.platform if platform is None else platform
+        self._home = None if home is None else Path(home)
+
+    def resolve(self) -> Path:
+        candidate = self._cli_data_root
+        if candidate is None:
+            candidate = self._environment.get("FORGE_DATA_ROOT")
+        if candidate is not None and str(candidate).strip():
+            return Path(candidate).expanduser().resolve()
+        return self.native_default()
+
+    def native_default(self) -> Path:
+        home = (self._home or Path(self._environment.get("HOME", str(Path.home())))).expanduser()
+        if self._platform == "darwin":
+            return (home / "Library" / "Application Support" / "Forge Server").resolve()
+        if self._platform.startswith("win"):
+            base = self._environment.get("LOCALAPPDATA")
+            return (Path(base) if base else home / "AppData" / "Local") .joinpath("Forge Server").resolve()
+        base = self._environment.get("XDG_DATA_HOME")
+        return (Path(base) if base else home / ".local" / "share").joinpath("forge-server").resolve()
+
+
+RUNTIME_DIRECTORIES = ("instance", "artifacts", "journals", "logs", "backups", "cache", "locks")

{forge_autonomy-2.3.1 → forge_autonomy-2.3.2}/forge/runtime/database.py

@@ -121,14 +121,14 @@ def _contains_secret_value(value: Any) -> bool:
 class RuntimeDatabase:
     """The sole Forge runtime database owner.
 
-    ``path`` is injectable for tests, but production defaults to
-    ``.forge/runtime.db`` beneath the supplied workspace root (or current
-    directory).  Opening is fail-closed: migrations and integrity validation
-    complete before callers receive the database.
+    ``path`` is injectable for controlled bootstrap and tests. Installed
+    production opens only the resolved ``forge.db`` in Forge's data root.
+    Opening is fail-closed: migrations and integrity validation complete
+    before callers receive the database.
     """
 
     def __init__(self, workspace_root: Path | str = ".", *, path: Path | str | None = None,
-                 forge_version: str = "0.0") -> None:
+                 forge_version: str = "0.0", installation_scoped: bool = False) -> None:
         if path is None:
             # Canonical creation and registration are a single inter-process
             # transaction owned by RuntimeBootstrap.  Keep this compatibility
@@ -138,8 +138,9 @@ class RuntimeDatabase:
             self.__dict__.update(opened.__dict__)
             return
         self.repository_root = canonical_repository_root(workspace_root)
-        # Explicit paths are reserved for bootstrap and relocation after their
-        # resolver/claim step.
+        self._installation_scoped = installation_scoped
+        # Explicit paths are reserved for bootstrap and controlled tests after
+        # their resolver/claim step.
         self.path = Path(path)
         self.path.parent.mkdir(parents=True, exist_ok=True)
         self._connection = sqlite3.connect(self.path)
@@ -1256,16 +1257,18 @@ class RuntimeDatabase:
             created_at = now
         values = {
             "runtime_id": metadata.get("runtime_id") or f"forge-runtime-{uuid.uuid4()}",
-            "repository_identity": metadata.get("repository_identity") or repository_identity(self.repository_root),
-            "repository_root": metadata.get("repository_root") or str(self.repository_root),
+            "repository_identity": metadata.get("repository_identity") or (
+                "forge-installation" if self._installation_scoped else repository_identity(self.repository_root)),
+            "repository_root": metadata.get("repository_root") or (
+                "forge-data-root" if self._installation_scoped else str(self.repository_root)),
             "database_version": str(RUNTIME_SCHEMA_VERSION), "instance_version": "1",
             "initialization_version": metadata.get("initialization_version") or RUNTIME_INITIALIZATION_VERSION,
-            "database_location": str(self.path.resolve()),
+            "database_location": "forge.db" if self._installation_scoped else str(self.path.resolve()),
             "created_at": created_at, "last_access_at": now, "status": "active",
         }
-        if values["repository_identity"] != repository_identity(self.repository_root):
+        if not self._installation_scoped and values["repository_identity"] != repository_identity(self.repository_root):
             raise RuntimeIntegrityError("runtime database belongs to a different repository")
-        current_repository_uuid = repository_uuid(self.repository_root)
+        current_repository_uuid = None if self._installation_scoped else repository_uuid(self.repository_root)
         stored_repository_uuid = metadata.get("repository_uuid")
         if stored_repository_uuid and current_repository_uuid and stored_repository_uuid != current_repository_uuid:
             raise RuntimeIntegrityError("runtime database repository UUID is inconsistent")
@@ -1322,9 +1325,10 @@ class RuntimeDatabase:
             raise RuntimeIntegrityError("runtime database schema version is inconsistent")
         self._require_canary_closure_structure()
         identity = self.runtime_identity
-        if identity.repository_identity != repository_identity(self.repository_root) or not identity.runtime_id or identity.status != "active":
+        expected_identity = "forge-installation" if self._installation_scoped else repository_identity(self.repository_root)
+        if identity.repository_identity != expected_identity or not identity.runtime_id or identity.status != "active":
             raise RuntimeIntegrityError("runtime identity is inconsistent")
-        current_repository_uuid = repository_uuid(self.repository_root)
+        current_repository_uuid = None if self._installation_scoped else repository_uuid(self.repository_root)
         if identity.repository_uuid and current_repository_uuid and identity.repository_uuid != current_repository_uuid:
             raise RuntimeIntegrityError("runtime identity repository UUID is inconsistent")
         if self._connection.execute("PRAGMA foreign_key_check").fetchone() is not None:

{forge_autonomy-2.3.1 → forge_autonomy-2.3.2/forge_autonomy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.3.1
+Version: 2.3.2
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0

{forge_autonomy-2.3.1 → forge_autonomy-2.3.2}/forge_autonomy.egg-info/SOURCES.txt

@@ -114,6 +114,7 @@ forge/review/__init__.py
 forge/review/engine.py
 forge/runtime/__init__.py
 forge/runtime/bootstrap.py
+forge/runtime/data_root.py
 forge/runtime/database.py
 forge/runtime/evidence.py
 forge/runtime/execution_context.py
@@ -201,6 +202,7 @@ tests/test_bootstrap_mission_scheduler.py
 tests/test_bootstrap_sequence_qualification.py
 tests/test_business_governance_ingress.py
 tests/test_business_workspace.py
+tests/test_canonical_data_root.py
 tests/test_capability_delegation.py
 tests/test_codex_cli_runtime_prompt.py
 tests/test_constitutional_validation.py

{forge_autonomy-2.3.1 → forge_autonomy-2.3.2}/product-version.json

@@ -1,5 +1,5 @@
 {
   "product": "forge",
   "schema_version": 1,
-  "version": "2.3.1"
+  "version": "2.3.2"
 }

forge_autonomy-2.3.2/tests/test_canonical_data_root.py

@@ -0,0 +1,75 @@
+"""Installed-runtime storage boundary regressions."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from forge.runtime import DataRootResolver, RuntimeBootstrap, RuntimeResolutionError, RuntimeResolver
+
+
+class CanonicalDataRootTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temporary = tempfile.TemporaryDirectory()
+        self.root = Path(self.temporary.name)
+        self.addCleanup(self.temporary.cleanup)
+
+    def test_macos_default_and_precedence_are_deterministic(self) -> None:
+        home = self.root / "home"
+        env_root = self.root / "environment"
+        cli_root = self.root / "cli"
+        resolver = DataRootResolver(environment={"HOME": str(home), "FORGE_DATA_ROOT": str(env_root)}, platform="darwin")
+        self.assertEqual(resolver.resolve(), env_root.resolve())
+        self.assertEqual(DataRootResolver(cli_data_root=cli_root, environment={"HOME": str(home), "FORGE_DATA_ROOT": str(env_root)}, platform="darwin").resolve(), cli_root.resolve())
+        self.assertEqual(DataRootResolver(environment={"HOME": str(home)}, platform="darwin").resolve(), (home / "Library" / "Application Support" / "Forge Server").resolve())
+
+    def test_resolution_help_version_and_status_do_not_create_a_root(self) -> None:
+        root = self.root / "safe"
+        self.assertEqual(RuntimeResolver(data_root=root).resolve().path, (root / "forge.db").resolve())
+        self.assertFalse(root.exists())
+        for arguments in (("--help",), ("--version",), ("--data-root", str(root), "server", "status")):
+            completed = subprocess.run((sys.executable, "-m", "forge", *arguments), capture_output=True, text=True, check=True)
+            self.assertTrue(completed.stdout)
+            self.assertFalse(root.exists())
+
+    def test_init_creates_one_root_and_stable_identity(self) -> None:
+        root = self.root / "canonical"
+        first = RuntimeBootstrap(data_root=root, forge_version="test").open()
+        identity = first.runtime_identity.runtime_id
+        first.close()
+        self.assertEqual(RuntimeResolver(data_root=root).resolve().path, (root / "forge.db").resolve())
+        self.assertTrue((root / "instance" / "runtime-instance.json").is_file())
+        self.assertTrue(all((root / name).is_dir() for name in ("artifacts", "journals", "logs", "backups", "cache", "locks")))
+        second = RuntimeBootstrap(data_root=root, forge_version="test").open()
+        try:
+            self.assertEqual(second.runtime_identity.runtime_id, identity)
+        finally:
+            second.close()
+
+    def test_roots_are_independent_and_legacy_git_storage_is_ignored(self) -> None:
+        checkout = self.root / "checkout"
+        legacy = checkout / ".git" / "forge-runtime"
+        legacy.mkdir(parents=True)
+        (legacy / "runtime.db").write_text("not a Forge database", encoding="utf-8")
+        first = RuntimeBootstrap(checkout, data_root=self.root / "one", forge_version="test").open()
+        second = RuntimeBootstrap(checkout, data_root=self.root / "two", forge_version="test").open()
+        try:
+            self.assertNotEqual(first.runtime_identity.runtime_id, second.runtime_identity.runtime_id)
+            self.assertEqual((legacy / "runtime.db").read_text(encoding="utf-8"), "not a Forge database")
+        finally:
+            first.close(); second.close()
+
+    def test_initialized_root_missing_database_fails_closed(self) -> None:
+        root = self.root / "missing"
+        database = RuntimeBootstrap(data_root=root, forge_version="test").open()
+        database.close()
+        (root / "forge.db").unlink()
+        with self.assertRaisesRegex(RuntimeResolutionError, "missing forge.db"):
+            RuntimeResolver(data_root=root).resolve()
+
+
+if __name__ == "__main__":
+    unittest.main()

{forge_autonomy-2.3.1 → forge_autonomy-2.3.2}/tests/test_runtime_bootstrap.py

@@ -46,7 +46,6 @@ class RuntimeBootstrapTests(unittest.TestCase):
         database = RuntimeBootstrap(self.root, configured_location=configured, forge_version="test").open()
         self.addCleanup(database.close)
         self.assertEqual(database.path, configured.resolve())
-        self.assertEqual(RuntimeResolver(self.root).resolve().path, configured.resolve())
 
     def test_runtime_identity_is_immutable(self) -> None:
         database = self._database()
@@ -69,27 +68,21 @@ class RuntimeBootstrapTests(unittest.TestCase):
         self.assertEqual(recovered["planning_state"]["planner_version"], "test")
         self.assertEqual(recovered["source"], "runtime_instance")
 
-    def test_multiple_runtime_candidates_fail_closed(self) -> None:
+    def test_checkout_candidates_are_not_discovered(self) -> None:
         database = self._database()
         database.close()
         duplicate = self.root / ".forge" / "duplicate" / "runtime-copy.db"
         duplicate.parent.mkdir(parents=True)
         duplicate.write_bytes(database.path.read_bytes())
-        with self.assertRaises(RuntimeResolutionError):
-            RuntimeResolver(self.root).resolve()
+        self.assertEqual(RuntimeResolver(self.root).resolve().path, database.path.resolve())
 
-    def test_relocation_preserves_runtime_identity_and_recovers_records(self) -> None:
+    def test_distinct_explicit_roots_have_distinct_instances(self) -> None:
         database = self._database()
-        self._persist_complete_runtime_slice(database)
         identity = database.runtime_identity.runtime_id
         database.close()
-        destination = self.root / "runtime-store" / "canonical.db"
-        location = RuntimeResolver(self.root).relocate(destination)
-        self.assertEqual(location.path, destination.resolve())
-        recovered = RuntimeBootstrap(self.root, forge_version="test").open()
+        recovered = RuntimeBootstrap(data_root=self.root / "runtime-store", forge_version="test").open()
         self.addCleanup(recovered.close)
-        self.assertEqual(recovered.runtime_identity.runtime_id, identity)
-        self.assertEqual(RuntimeRecovery(recovered).recover()["execution_receipts"][0]["receipt_id"], "receipt-1")
+        self.assertNotEqual(recovered.runtime_identity.runtime_id, identity)
 
 
 if __name__ == "__main__":