homegraph 1.5.0 → 1.5.2

package/scripts/exp_boundary_eval/run_session.py

@@ -1,158 +0,0 @@
-#!/usr/bin/env python3
-"""Run multi-turn session experiment (5). Supports multiple agents via --agent."""
-
-import os
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Optional
-
-import setup as setup_mod
-from _utils import (OUTPUT_DIR, append_run_log, build_agent_cmd,
-                    current_time_ms, find_experiment, get_agent, info, header,
-                    log, parse_output, resolve_agent_model, run_monitored_subprocess,
-                    subprocess_no_window_kwargs, write_json, warn)
-
-
-def run_session(exp_id: str = "5", skip_permissions: bool = True,
-                agent_name: str = "",
-                results_dir: Optional[Path] = None,
-                state_dir: Optional[Path] = None) -> bool:
-    exp = find_experiment(exp_id)
-    if exp is None:
-        print(f"ERROR: Experiment {exp_id} not found")
-        return False
-
-    agent = get_agent(agent_name)
-    clone_path = os.environ.get("REPO_CLONE", "")
-    local_repo = os.environ.get("REPO_PATH", "")
-    if clone_path:
-        repo_root = Path(clone_path)
-    elif local_repo:
-        repo_root = Path(local_repo)
-    else:
-        print("ERROR: No repo. Use run_all.py to clone, or set REPO_PATH / REPO_CLONE.")
-        return False
-    max_turns = exp.get("max_turns_per_round", 25)
-
-    header("Experiment 5: Session Persistence & Context Decay")
-    info(f"Agent: {agent['name']} ({agent['binary']}) | Repo: {repo_root}")
-    info(f"Max turns/round: {max_turns} | Permissions: {'skip' if skip_permissions else 'ask'}")
-
-    session_id, _ = setup_mod.prepare_environment("5", "full", agent_name,
-                                                    state_dir=state_dir)
-    log(f"Shared Session ID: {session_id}")
-
-    result_dir = results_dir / "5" if results_dir else OUTPUT_DIR / "5"
-    result_dir.mkdir(parents=True, exist_ok=True)
-
-    rounds_data = []
-    session_model = ""
-    deveco_session_id = ""
-    for round_num in range(1, 6):
-        ri = next((r for r in exp["rounds"] if r["round"] == round_num), None)
-        if not ri: continue
-
-        header(f"Round {round_num} of 5")
-        info(f"Title: {ri['title']}")
-
-        round_dir = result_dir / f"round_{round_num}"
-        round_dir.mkdir(parents=True, exist_ok=True)
-        (round_dir / "prompt.txt").write_text(ri["prompt"], encoding="utf-8")
-
-        start_ms = current_time_ms()
-        is_resume = round_num > 1
-
-        cmd = build_agent_cmd(agent, session_id, max_turns, ri["prompt"],
-                              resume=is_resume, skip_permissions=skip_permissions,
-                              repo_root=repo_root)
-
-        stream_path = round_dir / "stream_output.jsonl"
-        text_path = round_dir / "raw_output.txt"
-        track_hg = os.environ.get("EVAL_ARM", "") == "homegraph"
-
-        with open(stream_path, "w", encoding="utf-8") as stream_f:
-            result, mem = run_monitored_subprocess(
-                cmd, stdout=stream_f, stderr=subprocess.STDOUT, text=True,
-                track_homegraph=track_hg,
-            )
-        exit_code = result.returncode
-
-        end_ms = current_time_ms()
-        dur_ms = end_ms - start_ms
-        dur_s = f"{dur_ms / 1000:.1f}"
-
-        parser_name = agent.get("parser", "claude_stream_json")
-        stats = parse_output(stream_path, parser_name)
-        if not session_model:
-            session_model = resolve_agent_model(agent, stats)
-        if not deveco_session_id and stats.deveco_session_id:
-            deveco_session_id = stats.deveco_session_id
-
-        text_content = "\n".join(stats.text_lines)
-        text_path.write_text(text_content or "(no text output)", encoding="utf-8")
-
-        r2 = subprocess.run(
-            ["git", "diff", "--name-only"], capture_output=True, text=True, cwd=repo_root,
-            **subprocess_no_window_kwargs(),
-        )
-        mod_files = len([l for l in r2.stdout.strip().split("\n") if l])
-
-        rr = {"round": round_num, "title": ri["title"], "duration_ms": dur_ms,
-              "duration_s": dur_s, "exit_code": exit_code,
-              "tool_calls": stats.tool_calls, "tool_names": stats.tool_names,
-              "files_read": list(set(stats.files_read)),
-              "files_edited": list(set(stats.files_edited)),
-              "assistant_messages": stats.assistant_messages,
-              "max_turns_hit": stats.max_turns_hit,
-              "modified_files": mod_files, "max_turns": max_turns,
-              "memory": mem.to_dict()}
-        write_json(round_dir / "round_results.json", rr)
-        rounds_data.append(rr)
-
-        info(f"Round {round_num} done: {dur_s}s | Tool calls: {stats.tool_calls} | "
-             f"Files read: {len(set(stats.files_read))} | Edited: {mod_files}")
-        if stats.max_turns_hit:
-            warn(f"  Max turns ({max_turns}) hit in round {round_num}")
-        if round_num < 5:
-            time.sleep(2)
-
-    summary = {
-        "experiment_id": "5", "session_id": session_id, "agent": agent["name"],
-        "model": session_model,
-        "deveco_session_id": deveco_session_id,
-        "total_rounds": len(rounds_data),
-        "total_duration_ms": sum(r["duration_ms"] for r in rounds_data),
-        "total_tool_calls": sum(int(r["tool_calls"]) for r in rounds_data),
-        "memory_retention_curve": [
-            {"round": r["round"], "tool_calls": int(r["tool_calls"]),
-             "files_read": r.get("files_read", [])} for r in rounds_data
-        ],
-    }
-    write_json(result_dir / "session_results.json", summary)
-
-    print("\nMemory Retention Curve:")
-    for r in rounds_data:
-        tc = int(r["tool_calls"])
-        fr = len(r.get("files_read", []))
-        print(f"  Round {r['round']}: {'#' * (tc // 2)} ({tc} tool calls, {fr} files read)")
-
-    log(f"Results: {result_dir}/session_results.json")
-    return True
-
-
-if __name__ == "__main__":
-    args = sys.argv[1:]
-    exp_id = args[0] if args else "5"
-    agent_name = ""
-    skip = True
-    i = 1
-    while i < len(args):
-        if args[i] == "--agent" and i + 1 < len(args):
-            agent_name = args[i + 1]; i += 2
-        elif args[i] == "--no-skip-permissions":
-            skip = False; i += 1
-        else:
-            i += 1
-    sys.exit(0 if run_session(exp_id, skip, agent_name) else 1)

package/scripts/exp_boundary_eval/setup.py

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-"""Prepare a clean repo for an experiment run. Agent-aware."""
-
-import os
-import subprocess
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional, Tuple
-
-from _utils import (append_run_log, error, generate_session_id,
-                    get_agent, get_agent_version, git_output, git_ok, log,
-                    shell_ok, verify_agent_binary, write_json)
-from deveco_arm import git_clean_repo, write_deveco_project_config
-
-
-def prepare_environment(exp_id: str, clean_mode: str = "full",
-                        agent_name: str = "",
-                        state_dir: Optional[Path] = None) -> Tuple[str, str]:
-    """Prepare repo. Returns (session_id, agent_name)."""
-    clone_path = os.environ.get("REPO_CLONE", "")
-    is_clone = bool(clone_path and Path(clone_path).is_dir())
-    local_repo = os.environ.get("REPO_PATH", "")
-    if is_clone:
-        repo_root = Path(clone_path)
-    elif local_repo and Path(local_repo).is_dir():
-        repo_root = Path(local_repo)
-    else:
-        error("No repo available. Clone via run_all.py or set REPO_PATH / REPO_CLONE.")
-        sys.exit(1)
-
-    if state_dir is not None:
-        _state_dir = state_dir
-    else:
-        from _utils import LOG_DIR
-        _state_dir = LOG_DIR
-
-    if is_clone:
-        log(f"Using cloned repo: {repo_root}")
-    else:
-        log(f"Using local repo: {repo_root}")
-
-    os.chdir(repo_root)
-
-    # Agent config
-    agent = get_agent(agent_name)
-    binary = agent["binary"]
-
-    # Step 1: Clean repo
-    arm = os.environ.get("EVAL_ARM", "baseline")
-    if clean_mode == "full":
-        log("Restoring repo to clean state...")
-        branch = os.environ.get("BRANCH", "weekly_20260601")
-        shell_ok(f"git checkout {branch}")
-        git_ok(["checkout", "."], cwd=repo_root)
-        git_clean_repo(repo_root, arm)
-
-        current_branch = git_output(["branch", "--show-current"], cwd=repo_root)
-        commit = git_output(["rev-parse", "--short", "HEAD"], cwd=repo_root)
-        log(f"Branch: {current_branch} | Commit: {commit}")
-
-    # Step 1b: DevEco A/B project config (.deveco/deveco.jsonc)
-    if agent.get("binary") == "deveco":
-        write_deveco_project_config(repo_root, arm)
-
-    # Step 1c: Index rebuilt once at homegraph suite start (run_all / prebuild).
-    # Per-experiment git reset restores the same commit — no second index here.
-    # Step 2: Clear CLAUDE.md
-    claude_md = repo_root / "CLAUDE.md"
-    if claude_md.exists() and claude_md.stat().st_size > 0:
-        backup_dir = _state_dir / "claude_md_backups"
-        backup_dir.mkdir(parents=True, exist_ok=True)
-        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-        backup_path = backup_dir / f"CLAUDE.md.{ts}"
-        backup_path.write_text(claude_md.read_text())
-        log(f"Backed up CLAUDE.md → {backup_path}")
-    with open(claude_md, "w") as f:
-        f.write("")
-    log("Cleared CLAUDE.md")
-
-    for f in [".cursorrules", ".cursor/rules"]:
-        p = repo_root / f
-        if p.exists():
-            p.unlink()
-
-    # Step 3: Session ID
-    session_id = generate_session_id()
-    (_state_dir / f"session_{exp_id}.txt").write_text(session_id)
-    log(f"Session ID: {session_id}")
-
-    # Step 4: Verify agent binary
-    ok, resolved, err_msg = verify_agent_binary(agent)
-    if not ok:
-        error(err_msg)
-        sys.exit(1)
-    binary = resolved
-    agent_ver = get_agent_version(agent)
-    log(f"Agent: {agent['name']} ({binary}) v{agent_ver}")
-
-    # Step 5: Record state
-    write_json(_state_dir / exp_id / "state.json", {
-        "experiment_id": exp_id, "session_id": session_id,
-        "started_at": datetime.now(timezone.utc).isoformat(),
-        "clean_mode": clean_mode, "agent": agent["name"],
-        "agent_version": agent_ver, "repo_root": str(repo_root),
-        "git_branch": git_output(["branch", "--show-current"], cwd=repo_root),
-        "git_commit": git_output(["rev-parse", "HEAD"], cwd=repo_root),
-    })
-
-    append_run_log(_state_dir, f"Setup complete for {exp_id}: session={session_id}, agent={agent['name']}")
-    log("Setup complete.")
-    return session_id, agent["name"]
-
-
-if __name__ == "__main__":
-    exp_id = sys.argv[1] if len(sys.argv) > 1 else "all"
-    clean_mode = sys.argv[2] if len(sys.argv) > 2 else "full"
-    agent_name = sys.argv[3] if len(sys.argv) > 3 else ""
-    sid, _ = prepare_environment(exp_id, clean_mode, agent_name)
-    print(sid)

package/scripts/exp_boundary_eval/win_mcp_launcher.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-"""Windows MCP entry: pythonw (no window) → hidden node child; stdio inherited from DevEco."""
-
-from __future__ import annotations
-
-import os
-import shutil
-import subprocess
-import sys
-
-_CREATE_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
-
-# Applied here so MCP works even if DevEco ignores deveco.jsonc "environment".
-_MCP_ENV_DEFAULTS = {
-    "HOMEGRAPH_NO_DAEMON": "1",
-    "HOMEGRAPH_NO_WATCHDOG": "1",
-    "HOMEGRAPH_WASM_RELAUNCHED": "1",
-}
-
-
-def _resolve_node() -> str:
-    env_node = os.environ.get("HOMEGRAPH_NODE", "").strip()
-    if env_node:
-        return env_node
-    found = shutil.which("node")
-    if not found:
-        print("node not found on PATH", file=sys.stderr)
-        sys.exit(127)
-    return found
-
-
-def _node_argv(raw: list[str]) -> list[str]:
-    """Ensure --liftoff-only is on the node command line (before homegraph.js)."""
-    node = _resolve_node()
-    args = list(raw)
-    if "--liftoff-only" not in args:
-        args.insert(0, "--liftoff-only")
-    return [node, *args]
-
-
-def _hidden_call(argv: list[str], env: dict) -> int:
-    si = subprocess.STARTUPINFO()
-    si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-    si.wShowWindow = 0
-    return subprocess.call(
-        argv,
-        env=env,
-        stdin=sys.stdin,
-        stdout=sys.stdout,
-        stderr=sys.stderr,
-        creationflags=_CREATE_NO_WINDOW,
-        startupinfo=si,
-    )
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print(
-            "usage: win_mcp_launcher.py [--liftoff-only] [--stack-size=N] homegraph.js …",
-            file=sys.stderr,
-        )
-        return 2
-    env = os.environ.copy()
-    for key, val in _MCP_ENV_DEFAULTS.items():
-        env.setdefault(key, val)
-    argv = _node_argv(sys.argv[1:])
-    if os.name == "nt":
-        return _hidden_call(argv, env)
-    return subprocess.call(argv, env=env)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/scripts/exp_boundary_eval/win_mcp_stdio_wrap.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-/**
- * Windows MCP launcher: spawn homegraph with windowsHide while keeping stdio
- * connected to DevEco (pythonw + Python subprocess breaks JSON-RPC pipes).
- *
- * Usage: node win_mcp_stdio_wrap.js [--stack-size=N] homegraph.js serve --mcp --path <repo>
- */
-'use strict';
-
-const cp = require('child_process');
-
-const node = process.env.HOMEGRAPH_NODE || process.execPath;
-const args = process.argv.slice(2);
-if (args.length === 0) {
-  process.stderr.write('usage: node win_mcp_stdio_wrap.js [--stack-size=N] homegraph.js …\n');
-  process.exit(2);
-}
-
-const child = cp.spawn(node, args, {
-  stdio: 'inherit',
-  windowsHide: true,
-  env: process.env,
-});
-
-child.on('error', (err) => {
-  process.stderr.write(String(err) + '\n');
-  process.exit(1);
-});
-
-child.on('exit', (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-  process.exit(code ?? 1);
-});

package/scripts/exp_boundary_eval/win_node_launcher.py

@@ -1,24 +0,0 @@
-#!/usr/bin/env python3
-"""Windows: run node without a console window; inherit stdio (MCP / homegraph CLI)."""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-
-_CREATE_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print("usage: win_node_launcher.py [--stack-size=N] script.js …", file=sys.stderr)
-        return 2
-    node = os.environ.get("HOMEGRAPH_NODE", "node")
-    cmd = [node, *sys.argv[1:]]
-    flags = _CREATE_NO_WINDOW if os.name == "nt" else 0
-    return subprocess.call(cmd, creationflags=flags)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/scripts/extract-release-notes.mjs

@@ -1,130 +0,0 @@
-#!/usr/bin/env node
-/**
- * Extract a release-notes block from CHANGELOG.md for a given version
- * (or unwrap text supplied on stdin), then join hard-wrapped paragraphs.
- *
- * Why: GitHub renders release-note Markdown with GFM hard breaks, so
- * every `\n` becomes `<br>`. The CHANGELOG is hard-wrapped at ~75
- * chars for readable diffs, which then renders as awkward visible
- * line breaks on the release page. This script joins indented
- * continuation lines into a single line per bullet so the GFM
- * renderer produces clean paragraphs.
- *
- * Repo-level CHANGELOG.md viewing is unaffected (CommonMark treats
- * newlines as spaces there).
- *
- * Usage:
- *   extract-release-notes.mjs <version>     # read CHANGELOG.md
- *   extract-release-notes.mjs --stdin       # read from stdin (any text)
- */
-
-import { readFileSync } from 'fs';
-
-const arg = process.argv[2];
-if (!arg) {
-  console.error('usage: extract-release-notes.mjs <version> | --stdin');
-  process.exit(1);
-}
-
-let block;
-if (arg === '--stdin') {
-  block = readFileSync(0, 'utf8').replace(/\r\n?/g, '\n').split('\n');
-} else {
-  const version = arg;
-  const escaped = version.replace(/\./g, '\\.');
-  const headerRe = new RegExp(`^## \\[${escaped}\\]`);
-  const anyHeaderRe = /^## \[/;
-  const lines = readFileSync('CHANGELOG.md', 'utf8').split('\n');
-  const start = lines.findIndex((l) => headerRe.test(l));
-  if (start === -1) {
-    console.error(`no '## [${version}]' entry found in CHANGELOG.md`);
-    process.exit(1);
-  }
-  const after = lines.findIndex((l, i) => i > start && anyHeaderRe.test(l));
-  block = lines.slice(start, after === -1 ? lines.length : after);
-}
-
-// Track a stack of `{ indent: number }` frames so a continuation line
-// can attach to the right ancestor. Handles the post-nested-list
-// continuation pattern:
-//
-//     - top-level
-//         - nested
-//       back to top-level  <- 2-space indent, joins the top-level bullet
-const out = [];
-let buf = '';
-let stack = [];
-
-function flushBuf() {
-  if (buf !== '') {
-    out.push(buf);
-    buf = '';
-  }
-}
-
-function leadingSpaces(s) {
-  const m = s.match(/^(\s*)/);
-  return m ? m[1].length : 0;
-}
-
-// Bullets: `-`, `*`, `digit.` only. `+` is intentionally excluded — the
-// CHANGELOG uses literal `+` inline (`config + instructions`) and we
-// don't want to misread those as nested bullets.
-const listItemRe = /^(\s*)([-*]|\d+\.)\s+/;
-const fenceRe = /^\s*```/;
-
-let inFence = false;
-
-for (const line of block) {
-  // Fenced code blocks: pass through verbatim, no joining.
-  if (fenceRe.test(line)) {
-    flushBuf();
-    stack = [];
-    out.push(line);
-    inFence = !inFence;
-    continue;
-  }
-  if (inFence) {
-    out.push(line);
-    continue;
-  }
-  if (/^\s*$/.test(line)) {
-    flushBuf();
-    out.push('');
-    continue;
-  }
-  if (/^#/.test(line)) {
-    flushBuf();
-    stack = [];
-    out.push(line);
-    continue;
-  }
-  const itemMatch = line.match(listItemRe);
-  if (itemMatch) {
-    flushBuf();
-    const indent = itemMatch[1].length;
-    while (stack.length > 0 && stack[stack.length - 1].indent >= indent) {
-      stack.pop();
-    }
-    stack.push({ indent });
-    buf = line;
-    continue;
-  }
-  if (/^\s/.test(line)) {
-    const indent = leadingSpaces(line);
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-      flushBuf();
-      stack.pop();
-    }
-    const trimmed = line.replace(/^\s+/, '');
-    buf = buf === '' ? trimmed : `${buf} ${trimmed}`;
-    continue;
-  }
-  flushBuf();
-  stack = [];
-  out.push(line);
-}
-flushBuf();
-
-process.stdout.write(out.join('\n'));
-if (!out[out.length - 1]?.endsWith('\n')) process.stdout.write('\n');

package/scripts/local-install.sh

@@ -1,41 +0,0 @@
-#!/usr/bin/env bash
-# Build the current branch and link it as the global `homegraph` for
-# hands-on testing. Replaces any existing global install for as long
-# as the symlink is in place.
-#
-# Usage:
-#   ./scripts/local-install.sh           # build + link
-#   ./scripts/local-install.sh --undo    # unlink + restore the published version
-
-set -euo pipefail
-
-cd "$(dirname "$0")/.."
-
-PKG=$(node -p "require('./package.json').name")
-VERSION=$(node -p "require('./package.json').version")
-BRANCH=$(git rev-parse --abbrev-ref HEAD)
-
-if [ "${1:-}" = "--undo" ]; then
-  echo "→ unlinking ${PKG}"
-  npm unlink -g "${PKG}" >/dev/null 2>&1 || true
-  echo "→ reinstalling published ${PKG}"
-  npm install -g "${PKG}"
-  echo "done: global homegraph -> $(command -v homegraph)"
-  exit 0
-fi
-
-echo "→ building ${PKG} ${VERSION} (${BRANCH})"
-npm run build
-
-echo "→ linking globally"
-npm link
-
-LINKED=$(command -v homegraph || echo "(not on PATH)")
-echo
-echo "✓ global homegraph now points to this branch"
-echo "  binary:  ${LINKED}"
-echo "  branch:  ${BRANCH}"
-echo "  version: ${VERSION}"
-echo
-echo "To restore the published version:"
-echo "  ./scripts/local-install.sh --undo"

package/scripts/npm-sdk.js

@@ -1,75 +0,0 @@
-'use strict';
-//
-// Programmatic / embedded SDK entry for homegraph (issue #354).
-//
-// The CLI/MCP `bin` (npm-shim.js) execs the per-platform bundle's OWN Node 24 so
-// the tool never depends on the user's runtime. Embedded library consumers are
-// the opposite case: they already run their own Node and just want the compiled
-// API — `require("homegraph")` returning the HomeGraph class et al.
-//
-// The compiled library + its production dependencies (web-tree-sitter,
-// tree-sitter-wasms, …) ship INSIDE the per-platform bundle, at
-//   homegraph-<platform>-<arch>/lib/dist/index.js
-// (with the deps in the sibling lib/node_modules). Re-exporting that bundle keeps
-// the main package thin — no second 50 MB copy of the grammars — while making the
-// SDK work in the consumer's process. Types are a separate concern: the main
-// package ships its own dist/**/*.d.ts tree (pointed at by `types`), built from
-// the same release so it can never skew from the runtime it re-exports.
-//
-// node:sqlite (Node >= 22.5) is required to OPEN a graph, but only lazily inside
-// the SQLite adapter — so loading this module is safe on older Node, and the
-// node:sqlite requirement surfaces with an actionable error only when a DB is
-// actually opened. Heavy extraction additionally wants the bundled launcher's
-// --liftoff-only flag (the WASM Zone-OOM guard, issues #293/#298); an embedded
-// host that drives large indexing should pass that flag to its own Node.
-
-var path = require('path');
-var os = require('os');
-var fs = require('fs');
-
-var target = process.platform + '-' + process.arch; // e.g. darwin-arm64, linux-x64
-var pkg = 'homegraph-' + target;
-
-module.exports = require(resolveLibrary());
-
-// Locate the compiled library entry inside the installed per-platform bundle.
-// Throws an actionable error (rather than a bare MODULE_NOT_FOUND) when no bundle
-// is present, so an embedded consumer knows exactly what to install.
-function resolveLibrary() {
-  // 1) The npm-installed optional dependency — the normal case.
-  try {
-    return require.resolve(pkg + '/lib/dist/index.js');
-  } catch (e) {
-    /* fall through to the self-healed cache */
-  }
-
-  // 2) A bundle the CLI shim self-healed from GitHub Releases into the cache
-  //    (issue #303). Same node/lib/bin layout as the npm package. We only REUSE a
-  //    cached bundle here — unlike the CLI shim we never trigger a network
-  //    download from inside require(), which must stay synchronous and cheap.
-  var cached = cachedLibrary();
-  if (cached) return cached;
-
-  throw new Error(
-    'homegraph: the programmatic API is unavailable because the platform bundle\n' +
-    '(' + pkg + ') is not installed.\n' +
-    'The compiled library ships inside that per-platform optional dependency.\n' +
-    'Fixes:\n' +
-    '  - install from the official npm registry so the matching bundle is fetched:\n' +
-    '      npm i homegraph --registry=https://registry.npmjs.org\n' +
-    '  - or run the CLI once (e.g. `npx homegraph status`) to\n' +
-    '    self-heal the bundle into ~/.homegraph, then require() will find it.'
-  );
-}
-
-function cachedLibrary() {
-  try {
-    var version = require(path.join(__dirname, 'package.json')).version;
-    var base = process.env.HOMEGRAPH_INSTALL_DIR || path.join(os.homedir(), '.homegraph');
-    var lib = path.join(base, 'bundles', target + '-' + version, 'lib', 'dist', 'index.js');
-    if (fs.existsSync(lib)) return lib;
-  } catch (e) {
-    /* no readable cache → caller reports the install guidance */
-  }
-  return null;
-}