hyperflash 1.1.1__tar.gz → 1.1.2__tar.gz

{hyperflash-1.1.1/src/hyperflash.egg-info → hyperflash-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperflash
-Version: 1.1.1
+Version: 1.1.2
 Summary: Universal Engineering Reliability Runtime & Multi-Agent Verification Guardrails
 Author: Virat Ghatge
 License: MIT
@@ -184,7 +184,12 @@ Scaffold your preferred IDE or agent harness in 1 second:
 # Configure Cursor, Claude Code, Windsurf, Git Hooks, Antigravity, and OpenCode in one command
 hyperflash init
 
-# Or target your specific harness:
+# Configure globally across ALL workspaces (user home directory):
+# Sets up OpenCode (~/.config/opencode/opencode.json), Claude Code (~/.claude.json), and Antigravity globally
+hyperflash init --global    # or: hyperflash init -g
+
+# Or target your specific harness globally or locally:
+hyperflash init --target opencode --global
 hyperflash init --target cursor
 hyperflash init --target claude
 hyperflash init --target windsurf
@@ -193,6 +198,14 @@ hyperflash init --target antigravity
 hyperflash init --target opencode
 ```
 
+> [!TIP]
+> **Global Configuration Mode (`--global` / `-g`):**
+> When running `hyperflash init --global` (or `-g`), HyperFlash configures your user home directory rather than the current working folder. This means:
+> - **OpenCode:** Registers HyperFlash agent persona and MCP server in `~/.config/opencode/opencode.json` so `opencode --agent hyperflash` works anywhere on your system.
+> - **Claude Code:** Registers the MCP server in `~/.claude.json` and slash command in `~/.claude/commands/hyperflash.md`.
+> - **Antigravity:** Installs skills, agents, and rules globally in `~/.gemini/config/`.
+> You only need to run this once—no per-repository initialization required!
+
 ### 🚀 Universal Agent Launcher
 Launch your preferred coding environment with the native HyperFlash agent persona pre-activated:
 
@@ -352,9 +365,17 @@ OpenCode supports dedicated named agents natively. HyperFlash installs as a firs
 
 #### Step 1: Automatic Setup via CLI
 ```bash
+# Option A: Global setup (recommended) - works across all folders on your system:
+hyperflash init --target opencode --global
+
+# Option B: Local workspace setup - configures current repository:
 hyperflash init --target opencode
 ```
-This configures:
+
+**Global Setup (`--global`) configures:**
+- `~/.config/opencode/opencode.json`: Declares the global `hyperflash` agent persona and registers the stdio MCP server without overwriting existing agents or servers.
+
+**Local Setup configures:**
 - `OPENCODE.md`: OpenCode engineering constitution.
 - `.opencode/agents/hyperflash.json`: Dedicated agent persona definition.
 - `opencode.json`: Declares `agent: "hyperflash"`, registers agent configuration, and wires the `hyperflash` stdio MCP server.

{hyperflash-1.1.1 → hyperflash-1.1.2}/README.md

@@ -159,7 +159,12 @@ Scaffold your preferred IDE or agent harness in 1 second:
 # Configure Cursor, Claude Code, Windsurf, Git Hooks, Antigravity, and OpenCode in one command
 hyperflash init
 
-# Or target your specific harness:
+# Configure globally across ALL workspaces (user home directory):
+# Sets up OpenCode (~/.config/opencode/opencode.json), Claude Code (~/.claude.json), and Antigravity globally
+hyperflash init --global    # or: hyperflash init -g
+
+# Or target your specific harness globally or locally:
+hyperflash init --target opencode --global
 hyperflash init --target cursor
 hyperflash init --target claude
 hyperflash init --target windsurf
@@ -168,6 +173,14 @@ hyperflash init --target antigravity
 hyperflash init --target opencode
 ```
 
+> [!TIP]
+> **Global Configuration Mode (`--global` / `-g`):**
+> When running `hyperflash init --global` (or `-g`), HyperFlash configures your user home directory rather than the current working folder. This means:
+> - **OpenCode:** Registers HyperFlash agent persona and MCP server in `~/.config/opencode/opencode.json` so `opencode --agent hyperflash` works anywhere on your system.
+> - **Claude Code:** Registers the MCP server in `~/.claude.json` and slash command in `~/.claude/commands/hyperflash.md`.
+> - **Antigravity:** Installs skills, agents, and rules globally in `~/.gemini/config/`.
+> You only need to run this once—no per-repository initialization required!
+
 ### 🚀 Universal Agent Launcher
 Launch your preferred coding environment with the native HyperFlash agent persona pre-activated:
 
@@ -327,9 +340,17 @@ OpenCode supports dedicated named agents natively. HyperFlash installs as a firs
 
 #### Step 1: Automatic Setup via CLI
 ```bash
+# Option A: Global setup (recommended) - works across all folders on your system:
+hyperflash init --target opencode --global
+
+# Option B: Local workspace setup - configures current repository:
 hyperflash init --target opencode
 ```
-This configures:
+
+**Global Setup (`--global`) configures:**
+- `~/.config/opencode/opencode.json`: Declares the global `hyperflash` agent persona and registers the stdio MCP server without overwriting existing agents or servers.
+
+**Local Setup configures:**
 - `OPENCODE.md`: OpenCode engineering constitution.
 - `.opencode/agents/hyperflash.json`: Dedicated agent persona definition.
 - `opencode.json`: Declares `agent: "hyperflash"`, registers agent configuration, and wires the `hyperflash` stdio MCP server.

{hyperflash-1.1.1 → hyperflash-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyperflash"
-version = "1.1.1"
+version = "1.1.2"
 description = "Universal Engineering Reliability Runtime & Multi-Agent Verification Guardrails"
 readme = "README.md"
 requires-python = ">=3.10"

{hyperflash-1.1.1 → hyperflash-1.1.2}/src/hyperflash/__init__.py

@@ -14,7 +14,7 @@ from hyperflash.core import (
     save_contract,
 )
 
-__version__: str = "1.1.1"
+__version__: str = "1.1.2"
 
 __all__: list[str] = [
     "__version__",

{hyperflash-1.1.1 → hyperflash-1.1.2}/src/hyperflash/cli.py

@@ -36,37 +36,39 @@ def cmd_init(args: argparse.Namespace) -> int:
     """Handles 'hyperflash init' command."""
     target: str = args.target.lower()
     workspace: str = args.workspace
+    is_global: bool = getattr(args, "is_global", False)
 
-    print(f"⚡ HyperFlash: Initializing reliability runtime for target '{target}' in '{workspace}'...")
+    target_desc: str = "globally in user home" if is_global else f"in '{workspace}'"
+    print(f"⚡ HyperFlash: Initializing reliability runtime for target '{target}' {target_desc}...")
 
     if target == "all":
-        results = setup_all(workspace)
+        results = setup_all(workspace, is_global=is_global)
         for platform, files in results.items():
             print(f"  • {platform.capitalize()}:")
             for f in files:
                 print(f"    - Configured: {f}")
     elif target == "cursor":
-        files = setup_cursor(workspace)
+        files = setup_cursor(workspace, is_global=is_global)
         for f in files:
             print(f"  • Configured Cursor: {f}")
     elif target == "claude":
-        files = setup_claude(workspace)
+        files = setup_claude(workspace, is_global=is_global)
         for f in files:
             print(f"  • Configured Claude Code: {f}")
     elif target == "windsurf":
-        files = setup_windsurf(workspace)
+        files = setup_windsurf(workspace, is_global=is_global)
         for f in files:
             print(f"  • Configured Windsurf: {f}")
     elif target == "git":
-        files = setup_git_hooks(workspace)
+        files = setup_git_hooks(workspace, is_global=is_global)
         for f in files:
             print(f"  • Configured Git pre-commit hook: {f}")
     elif target == "antigravity":
-        files = setup_antigravity(workspace)
+        files = setup_antigravity(workspace, is_global=is_global)
         for f in files:
             print(f"  • Configured Antigravity: {f}")
     elif target == "opencode":
-        files = setup_opencode(workspace)
+        files = setup_opencode(workspace, is_global=is_global)
         for f in files:
             print(f"  • Configured OpenCode: {f}")
     else:
@@ -244,6 +246,13 @@ def build_parser() -> argparse.ArgumentParser:
         default=".",
         help="Workspace root directory (default: .)",
     )
+    p_init.add_argument(
+        "-g",
+        "--global",
+        dest="is_global",
+        action="store_true",
+        help="Configure globally in user home directory across all workspaces",
+    )
 
     # launch
     p_launch = subparsers.add_parser("launch", help="Launch your preferred coding harness with HyperFlash agent active")

{hyperflash-1.1.1 → hyperflash-1.1.2}/src/hyperflash/polyglot.py

@@ -144,6 +144,31 @@ OPENCODE_CONFIG_DICT: dict[str, Any] = {
     },
 }
 
+OPENCODE_GLOBAL_CONFIG_DICT: dict[str, Any] = {
+    "agent": {
+        "hyperflash": {
+            "name": "HyperFlash",
+            "description": "Universal Engineering Reliability & Multi-Agent Verification Runtime",
+            "system": (
+                "You are HYPERFLASH, the Principal Multi-Agent Engineering Reliability Orchestrator. "
+                "You operate strictly under the 8 HyperFlash Invariants: 1. Ground before mutating. "
+                "2. Stay in declared scope. 3. Fresh evidence required before completion. "
+                "4. Never exact-retry failed modifications. 5. Satisfy acceptance criteria. "
+                "6. Report reality only. 7. ZERO code elision. 8. Exhaustive static typing. "
+                "Always use hyperflash_safe_patch to mutate files, and run hyperflash_verify before claiming a task is done."
+            ),
+        }
+    },
+    "mcp": {
+        "servers": {
+            "hyperflash": {
+                "type": "local",
+                "command": ["hyperflash", "mcp"],
+            }
+        }
+    },
+}
+
 GIT_PRE_COMMIT_CONTENT: str = """#!/usr/bin/env bash
 # HyperFlash Zero-Elision & Integrity Gate
 set -e
@@ -208,86 +233,129 @@ def merge_json_config(file_path: Path, new_data: dict[str, Any]) -> None:
         else:
             existing["agents"] = new_data["agents"]
 
+    # Merge nested 'agent' dict if both are dicts
+    if "agent" in new_data:
+        if isinstance(new_data["agent"], dict):
+            agent_dict = existing.get("agent", {})
+            if isinstance(agent_dict, dict):
+                agent_dict.update(new_data["agent"])
+                existing["agent"] = agent_dict
+            else:
+                existing["agent"] = new_data["agent"]
+        else:
+            existing["agent"] = new_data["agent"]
+
+    # Merge nested 'mcp' dict (OpenCode global config schema: {"mcp": {"servers": {...}}})
+    if "mcp" in new_data:
+        if isinstance(new_data["mcp"], dict):
+            mcp_dict = existing.get("mcp", {})
+            if isinstance(mcp_dict, dict):
+                servers = mcp_dict.get("servers", {})
+                new_servers = new_data["mcp"].get("servers", {})
+                if isinstance(servers, dict) and isinstance(new_servers, dict):
+                    servers.update(new_servers)
+                    mcp_dict["servers"] = servers
+                else:
+                    mcp_dict.update(new_data["mcp"])
+                existing["mcp"] = mcp_dict
+            else:
+                existing["mcp"] = new_data["mcp"]
+        else:
+            existing["mcp"] = new_data["mcp"]
+
     for k, v in new_data.items():
-        if k not in ("mcpServers", "agents"):
+        if k not in ("mcpServers", "agents", "agent", "mcp"):
             existing[k] = v
 
     file_path.write_text(json.dumps(existing, indent=2), encoding="utf-8")
 
 
-def setup_cursor(workspace_dir: Path | str = ".") -> list[str]:
+def setup_cursor(workspace_dir: Path | str = ".", is_global: bool = False) -> list[str]:
     """
     Configures HyperFlash rules, agent rule mdc, and stdio MCP server for Cursor.
     """
-    workspace = Path(workspace_dir).resolve()
+    target_root = Path.home() if is_global else Path(workspace_dir).resolve()
     created_files: list[str] = []
 
-    rules_path = workspace / ".cursorrules"
+    rules_path = target_root / ".cursorrules"
     rules_path.write_text(CURSOR_RULES_CONTENT, encoding="utf-8")
     created_files.append(str(rules_path))
 
-    rules_dir = workspace / ".cursor" / "rules"
+    rules_dir = target_root / ".cursor" / "rules"
     rules_dir.mkdir(parents=True, exist_ok=True)
     mdc_path = rules_dir / "hyperflash.mdc"
     mdc_path.write_text(CURSOR_RULE_MDC_CONTENT, encoding="utf-8")
     created_files.append(str(mdc_path))
 
-    mcp_path = workspace / ".cursor" / "mcp.json"
+    mcp_path = target_root / ".cursor" / "mcp.json"
     merge_json_config(mcp_path, MCP_CONFIG_DICT)
     created_files.append(str(mcp_path))
 
     return created_files
 
 
-def setup_claude(workspace_dir: Path | str = ".") -> list[str]:
+def setup_claude(workspace_dir: Path | str = ".", is_global: bool = False) -> list[str]:
     """
     Configures HyperFlash rules, slash command, and stdio MCP server for Claude Code.
     """
-    workspace = Path(workspace_dir).resolve()
     created_files: list[str] = []
 
-    claude_md = workspace / "CLAUDE.md"
-    claude_md.write_text(CLAUDE_MD_CONTENT, encoding="utf-8")
-    created_files.append(str(claude_md))
-
-    commands_dir = workspace / ".claude" / "commands"
-    commands_dir.mkdir(parents=True, exist_ok=True)
-    cmd_file = commands_dir / "hyperflash.md"
-    cmd_file.write_text(CLAUDE_COMMAND_MD_CONTENT, encoding="utf-8")
-    created_files.append(str(cmd_file))
-
-    claude_json = workspace / ".claude.json"
-    merge_json_config(claude_json, MCP_CONFIG_DICT)
-    created_files.append(str(claude_json))
+    if is_global:
+        home = Path.home()
+        commands_dir = home / ".claude" / "commands"
+        commands_dir.mkdir(parents=True, exist_ok=True)
+        cmd_file = commands_dir / "hyperflash.md"
+        cmd_file.write_text(CLAUDE_COMMAND_MD_CONTENT, encoding="utf-8")
+        created_files.append(str(cmd_file))
+
+        claude_json = home / ".claude.json"
+        merge_json_config(claude_json, MCP_CONFIG_DICT)
+        created_files.append(str(claude_json))
+    else:
+        workspace = Path(workspace_dir).resolve()
+
+        claude_md = workspace / "CLAUDE.md"
+        claude_md.write_text(CLAUDE_MD_CONTENT, encoding="utf-8")
+        created_files.append(str(claude_md))
+
+        commands_dir = workspace / ".claude" / "commands"
+        commands_dir.mkdir(parents=True, exist_ok=True)
+        cmd_file = commands_dir / "hyperflash.md"
+        cmd_file.write_text(CLAUDE_COMMAND_MD_CONTENT, encoding="utf-8")
+        created_files.append(str(cmd_file))
+
+        claude_json = workspace / ".claude.json"
+        merge_json_config(claude_json, MCP_CONFIG_DICT)
+        created_files.append(str(claude_json))
 
     return created_files
 
 
-def setup_windsurf(workspace_dir: Path | str = ".") -> list[str]:
+def setup_windsurf(workspace_dir: Path | str = ".", is_global: bool = False) -> list[str]:
     """
     Configures HyperFlash rules, agent persona rule, and stdio MCP server for Windsurf.
     """
-    workspace = Path(workspace_dir).resolve()
+    target_root = Path.home() if is_global else Path(workspace_dir).resolve()
     created_files: list[str] = []
 
-    rules_path = workspace / ".windsurfrules"
+    rules_path = target_root / ".windsurfrules"
     rules_path.write_text(WINDSURF_RULES_CONTENT, encoding="utf-8")
     created_files.append(str(rules_path))
 
-    rules_dir = workspace / ".windsurf" / "rules"
+    rules_dir = target_root / ".windsurf" / "rules"
     rules_dir.mkdir(parents=True, exist_ok=True)
     rule_md_path = rules_dir / "hyperflash.md"
     rule_md_path.write_text(WINDSURF_RULE_MD_CONTENT, encoding="utf-8")
     created_files.append(str(rule_md_path))
 
-    mcp_path = workspace / ".windsurf" / "mcp.json"
+    mcp_path = target_root / ".windsurf" / "mcp.json"
     merge_json_config(mcp_path, MCP_CONFIG_DICT)
     created_files.append(str(mcp_path))
 
     return created_files
 
 
-def setup_git_hooks(workspace_dir: Path | str = ".") -> list[str]:
+def setup_git_hooks(workspace_dir: Path | str = ".", is_global: bool = False) -> list[str]:
     """
     Installs HyperFlash pre-commit hook into .git/hooks.
     """
@@ -295,6 +363,9 @@ def setup_git_hooks(workspace_dir: Path | str = ".") -> list[str]:
     git_hooks_dir = workspace / ".git" / "hooks"
     created_files: list[str] = []
 
+    if is_global and not (workspace / ".git").exists():
+        return created_files
+
     git_hooks_dir.mkdir(parents=True, exist_ok=True)
 
     hook_file = git_hooks_dir / "pre-commit"
@@ -309,7 +380,7 @@ def setup_git_hooks(workspace_dir: Path | str = ".") -> list[str]:
     return created_files
 
 
-def setup_antigravity(workspace_dir: Path | str = ".") -> list[str]:
+def setup_antigravity(workspace_dir: Path | str = ".", is_global: bool = False) -> list[str]:
     """
     Installs or updates HyperFlash skill and agents in Antigravity (~/.gemini/config/).
     """
@@ -349,39 +420,47 @@ def setup_antigravity(workspace_dir: Path | str = ".") -> list[str]:
     return created_files
 
 
-def setup_opencode(workspace_dir: Path | str = ".") -> list[str]:
+def setup_opencode(workspace_dir: Path | str = ".", is_global: bool = False) -> list[str]:
     """
     Configures HyperFlash rules, agent persona, and stdio MCP server for OpenCode.
+    If is_global is True, writes to user global config: ~/.config/opencode/opencode.json.
+    If not purely global, also writes local workspace files: OPENCODE.md, .opencode/agents/hyperflash.json, opencode.json.
     """
-    workspace = Path(workspace_dir).resolve()
     created_files: list[str] = []
 
-    opencode_md = workspace / "OPENCODE.md"
-    opencode_md.write_text(OPENCODE_MD_CONTENT, encoding="utf-8")
-    created_files.append(str(opencode_md))
+    if is_global:
+        global_config_path = Path.home() / ".config" / "opencode" / "opencode.json"
+        merge_json_config(global_config_path, OPENCODE_GLOBAL_CONFIG_DICT)
+        created_files.append(str(global_config_path))
+    else:
+        workspace = Path(workspace_dir).resolve()
+
+        opencode_md = workspace / "OPENCODE.md"
+        opencode_md.write_text(OPENCODE_MD_CONTENT, encoding="utf-8")
+        created_files.append(str(opencode_md))
 
-    agent_dir = workspace / ".opencode" / "agents"
-    agent_dir.mkdir(parents=True, exist_ok=True)
-    agent_json_path = agent_dir / "hyperflash.json"
-    agent_json_path.write_text(json.dumps(OPENCODE_AGENT_DICT, indent=2), encoding="utf-8")
-    created_files.append(str(agent_json_path))
+        agent_dir = workspace / ".opencode" / "agents"
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        agent_json_path = agent_dir / "hyperflash.json"
+        agent_json_path.write_text(json.dumps(OPENCODE_AGENT_DICT, indent=2), encoding="utf-8")
+        created_files.append(str(agent_json_path))
 
-    opencode_json = workspace / "opencode.json"
-    merge_json_config(opencode_json, OPENCODE_CONFIG_DICT)
-    created_files.append(str(opencode_json))
+        opencode_json = workspace / "opencode.json"
+        merge_json_config(opencode_json, OPENCODE_CONFIG_DICT)
+        created_files.append(str(opencode_json))
 
     return created_files
 
 
-def setup_all(workspace_dir: Path | str = ".") -> dict[str, list[str]]:
+def setup_all(workspace_dir: Path | str = ".", is_global: bool = False) -> dict[str, list[str]]:
     """
     Executes polyglot configuration across all supported platforms.
     """
     return {
-        "cursor": setup_cursor(workspace_dir),
-        "claude": setup_claude(workspace_dir),
-        "windsurf": setup_windsurf(workspace_dir),
-        "git": setup_git_hooks(workspace_dir),
-        "antigravity": setup_antigravity(workspace_dir),
-        "opencode": setup_opencode(workspace_dir),
+        "cursor": setup_cursor(workspace_dir, is_global=is_global),
+        "claude": setup_claude(workspace_dir, is_global=is_global),
+        "windsurf": setup_windsurf(workspace_dir, is_global=is_global),
+        "git": setup_git_hooks(workspace_dir, is_global=is_global),
+        "antigravity": setup_antigravity(workspace_dir, is_global=is_global),
+        "opencode": setup_opencode(workspace_dir, is_global=is_global),
     }

{hyperflash-1.1.1 → hyperflash-1.1.2/src/hyperflash.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperflash
-Version: 1.1.1
+Version: 1.1.2
 Summary: Universal Engineering Reliability Runtime & Multi-Agent Verification Guardrails
 Author: Virat Ghatge
 License: MIT
@@ -184,7 +184,12 @@ Scaffold your preferred IDE or agent harness in 1 second:
 # Configure Cursor, Claude Code, Windsurf, Git Hooks, Antigravity, and OpenCode in one command
 hyperflash init
 
-# Or target your specific harness:
+# Configure globally across ALL workspaces (user home directory):
+# Sets up OpenCode (~/.config/opencode/opencode.json), Claude Code (~/.claude.json), and Antigravity globally
+hyperflash init --global    # or: hyperflash init -g
+
+# Or target your specific harness globally or locally:
+hyperflash init --target opencode --global
 hyperflash init --target cursor
 hyperflash init --target claude
 hyperflash init --target windsurf
@@ -193,6 +198,14 @@ hyperflash init --target antigravity
 hyperflash init --target opencode
 ```
 
+> [!TIP]
+> **Global Configuration Mode (`--global` / `-g`):**
+> When running `hyperflash init --global` (or `-g`), HyperFlash configures your user home directory rather than the current working folder. This means:
+> - **OpenCode:** Registers HyperFlash agent persona and MCP server in `~/.config/opencode/opencode.json` so `opencode --agent hyperflash` works anywhere on your system.
+> - **Claude Code:** Registers the MCP server in `~/.claude.json` and slash command in `~/.claude/commands/hyperflash.md`.
+> - **Antigravity:** Installs skills, agents, and rules globally in `~/.gemini/config/`.
+> You only need to run this once—no per-repository initialization required!
+
 ### 🚀 Universal Agent Launcher
 Launch your preferred coding environment with the native HyperFlash agent persona pre-activated:
 
@@ -352,9 +365,17 @@ OpenCode supports dedicated named agents natively. HyperFlash installs as a firs
 
 #### Step 1: Automatic Setup via CLI
 ```bash
+# Option A: Global setup (recommended) - works across all folders on your system:
+hyperflash init --target opencode --global
+
+# Option B: Local workspace setup - configures current repository:
 hyperflash init --target opencode
 ```
-This configures:
+
+**Global Setup (`--global`) configures:**
+- `~/.config/opencode/opencode.json`: Declares the global `hyperflash` agent persona and registers the stdio MCP server without overwriting existing agents or servers.
+
+**Local Setup configures:**
 - `OPENCODE.md`: OpenCode engineering constitution.
 - `.opencode/agents/hyperflash.json`: Dedicated agent persona definition.
 - `opencode.json`: Declares `agent: "hyperflash"`, registers agent configuration, and wires the `hyperflash` stdio MCP server.

{hyperflash-1.1.1 → hyperflash-1.1.2}/tests/test_cli.py

@@ -30,7 +30,7 @@ def test_cli_version_flag(capsys: pytest.CaptureFixture[str]) -> None:
         parser.parse_args(["--version"])
     assert exc_info.value.code == 0
     captured = capsys.readouterr()
-    assert "hyperflash 1.1.1" in captured.out
+    assert "hyperflash 1.1.2" in captured.out
 
 
 def test_cli_decide_updates_contract(tmp_path: Path) -> None:
@@ -172,6 +172,59 @@ def test_cli_init_all(tmp_path: Path) -> None:
     assert (tmp_path / "opencode.json").exists()
 
 
+def test_cli_init_global_flag_parsing() -> None:
+    """Verifies that -g and --global flags correctly set is_global attribute on parsed args."""
+    parser = build_parser()
+    args_short = parser.parse_args(["init", "-g"])
+    assert args_short.is_global is True
+
+    args_long = parser.parse_args(["init", "--global"])
+    assert args_long.is_global is True
+
+    args_default = parser.parse_args(["init"])
+    assert args_default.is_global is False
+
+
+def test_cli_init_opencode_global(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Verifies that 'hyperflash init --target opencode --global' writes to user global config."""
+    fake_home = tmp_path / "fake_home"
+    fake_home.mkdir()
+    monkeypatch.setattr(Path, "home", lambda: fake_home)
+
+    parser = build_parser()
+    args = parser.parse_args(["init", "--target", "opencode", "--global"])
+    exit_code = cmd_init(args)
+    assert exit_code == 0
+
+    global_config = fake_home / ".config" / "opencode" / "opencode.json"
+    assert global_config.exists()
+    data = json.loads(global_config.read_text(encoding="utf-8"))
+    assert "agent" in data
+    assert "hyperflash" in data["agent"]
+    assert data["agent"]["hyperflash"]["name"] == "HyperFlash"
+    assert "mcp" in data
+    assert "servers" in data["mcp"]
+    assert "hyperflash" in data["mcp"]["servers"]
+
+
+def test_cli_init_all_global(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Verifies that 'hyperflash init --global' configures harnesses in user home."""
+    fake_home = tmp_path / "fake_home"
+    fake_home.mkdir()
+    monkeypatch.setattr(Path, "home", lambda: fake_home)
+
+    parser = build_parser()
+    args = parser.parse_args(["init", "--global"])
+    exit_code = cmd_init(args)
+    assert exit_code == 0
+
+    assert (fake_home / ".config" / "opencode" / "opencode.json").exists()
+    assert (fake_home / ".claude.json").exists()
+    assert (fake_home / ".claude" / "commands" / "hyperflash.md").exists()
+    assert (fake_home / ".cursorrules").exists()
+    assert (fake_home / ".windsurfrules").exists()
+
+
 def test_cli_launch_missing_harness(capsys: pytest.CaptureFixture[str]) -> None:
     """Verifies that launching a harness not found in PATH returns 1 and friendly error."""
     parser = build_parser()

{hyperflash-1.1.1 → hyperflash-1.1.2}/tests/test_core.py

@@ -4,6 +4,7 @@ Tests elision detection, symbol graph generation, contract lifecycle, and verifi
 """
 from __future__ import annotations
 
+import json
 from pathlib import Path
 
 import pytest
@@ -185,3 +186,73 @@ def test_setup_opencode(tmp_path: Path) -> None:
     assert "mcpServers" in content
     assert "hyperflash" in content
     assert '"agent": "hyperflash"' in content
+
+
+def test_setup_opencode_global(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Verifies that setup_opencode(is_global=True) writes to ~/.config/opencode/opencode.json."""
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setattr(Path, "home", lambda: fake_home)
+
+    created = setup_opencode(is_global=True)
+    assert len(created) == 1
+
+    expected_path = fake_home / ".config" / "opencode" / "opencode.json"
+    assert str(expected_path) == created[0]
+    assert expected_path.exists()
+
+    data = json.loads(expected_path.read_text(encoding="utf-8"))
+    assert "agent" in data
+    assert "hyperflash" in data["agent"]
+    hf_agent = data["agent"]["hyperflash"]
+    assert hf_agent["name"] == "HyperFlash"
+    assert "Universal Engineering Reliability" in hf_agent["description"]
+    assert "8 HyperFlash Invariants" in hf_agent["system"]
+
+    assert "mcp" in data
+    assert "servers" in data["mcp"]
+    assert "hyperflash" in data["mcp"]["servers"]
+    hf_server = data["mcp"]["servers"]["hyperflash"]
+    assert hf_server["type"] == "local"
+    assert hf_server["command"] == ["hyperflash", "mcp"]
+
+
+def test_setup_opencode_global_merges_without_overwriting(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Verifies that global config setup safely merges without deleting existing agents or servers."""
+    fake_home = tmp_path / "home"
+    config_dir = fake_home / ".config" / "opencode"
+    config_dir.mkdir(parents=True)
+    target_file = config_dir / "opencode.json"
+
+    initial_config = {
+        "agent": {
+            "custom_coder": {
+                "name": "Custom Coder",
+                "system": "You write code."
+            }
+        },
+        "mcp": {
+            "servers": {
+                "git_mcp": {
+                    "type": "local",
+                    "command": ["git-mcp"]
+                }
+            }
+        },
+        "custom_setting": True
+    }
+    target_file.write_text(json.dumps(initial_config), encoding="utf-8")
+    monkeypatch.setattr(Path, "home", lambda: fake_home)
+
+    created = setup_opencode(is_global=True)
+    assert len(created) == 1
+
+    data = json.loads(target_file.read_text(encoding="utf-8"))
+    assert "custom_coder" in data["agent"]
+    assert "hyperflash" in data["agent"]
+    assert "git_mcp" in data["mcp"]["servers"]
+    assert "hyperflash" in data["mcp"]["servers"]
+    assert data["custom_setting"] is True