homegraph 1.1.3 → 1.4.1

package/scripts/exp_boundary_eval/run_session.py

@@ -0,0 +1,158 @@
+#!/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

@@ -0,0 +1,120 @@
+#!/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

@@ -0,0 +1,73 @@
+#!/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

@@ -0,0 +1,36 @@
+#!/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

@@ -0,0 +1,24 @@
+#!/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/npm-shim.js

@@ -45,7 +45,14 @@ async function main() {
   // Happy path: the npm-installed optional dependency. Fall back to a download
   // when the registry didn't deliver it.
   var resolved = resolveInstalledBundle() || (await selfHealBundle());
-  var res = childProcess.spawnSync(resolved.command, resolved.args, { stdio: 'inherit' });
+  // Thread the MCP host's pid (our parent) down to the bundled server so its
+  // orphan watchdog can poll the host directly. Without this, the server can
+  // only watch THIS shim — and a shim killed during the server's first ~100ms
+  // of startup used to leave the server orphaned forever (issue #1185). An
+  // already-set value (an outer launcher) wins.
+  var env = Object.assign({}, process.env);
+  if (!env.HOMEGRAPH_HOST_PPID) env.HOMEGRAPH_HOST_PPID = String(process.ppid);
+  var res = childProcess.spawnSync(resolved.command, resolved.args, { stdio: 'inherit', windowsHide: true, env: env });
   if (res.error) {
     process.stderr.write('homegraph: ' + res.error.message + '\n');
     process.exit(1);
@@ -105,7 +112,7 @@ async function selfHealBundle() {
   // Already downloaded by a previous run? Use it even when downloads are
   // disabled — HOMEGRAPH_NO_DOWNLOAD blocks fetching, not a cached bundle.
   var cached = launcherIn(dest);
-  if (cached) return cached;
+  if (cached) { pruneOldBundles(bundlesDir, dest); return cached; }
 
   if (process.env.HOMEGRAPH_NO_DOWNLOAD) {
     fail('the network fallback is disabled (HOMEGRAPH_NO_DOWNLOAD is set).');
@@ -149,6 +156,7 @@ async function selfHealBundle() {
 
   var ready = launcherIn(dest);
   if (!ready) fail('downloaded bundle is missing its launcher under ' + dest + '.');
+  pruneOldBundles(bundlesDir, dest);
   process.stderr.write('homegraph: bundle ready.\n');
   return ready;
 }
@@ -221,7 +229,7 @@ function extract(archive, destDir) {
   var args = isWindows
     ? ['-xf', archive, '-C', destDir, '--strip-components=1']
     : ['-xzf', archive, '-C', destDir, '--strip-components=1'];
-  var res = childProcess.spawnSync('tar', args, { stdio: 'ignore' });
+  var res = childProcess.spawnSync('tar', args, { stdio: 'ignore', windowsHide: true });
   if (res.error) throw new Error('tar unavailable: ' + res.error.message);
   if (res.status !== 0) throw new Error('tar exited ' + res.status);
 }
@@ -230,6 +238,27 @@ function rmrf(p) {
   try { fs.rmSync(p, { recursive: true, force: true }); } catch (e) { /* best effort */ }
 }
 
+// Drop sibling bundles for OTHER versions of this same platform target, keeping
+// only keepDir. The self-heal cache otherwise accumulates a full ~50 MB bundle
+// per version forever (issue #1074). Best-effort: a locked/busy dir (a
+// concurrent run still mapping an older node.exe on Windows) just stays — rmrf
+// already swallows its own errors, and the readdir is guarded — so cleanup can
+// never break a working command. Only this target's "<target>-<version>" dirs
+// are touched; other platforms' bundles and the ".dl-*" staging dirs are left
+// alone.
+function pruneOldBundles(bundlesDir, keepDir) {
+  var keep = path.basename(keepDir);
+  try {
+    var names = fs.readdirSync(bundlesDir);
+    for (var i = 0; i < names.length; i++) {
+      var name = names[i];
+      if (name === keep) continue;
+      if (name.indexOf(target + '-') !== 0) continue;
+      rmrf(path.join(bundlesDir, name));
+    }
+  } catch (e) { /* best effort — never break a working run over cleanup */ }
+}
+
 function fail(reason) {
   process.stderr.write(
     'homegraph: no prebuilt bundle for ' + target + '.\n' +

package/scripts/ohos-sdk-publish.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+/**
+ * Build and optionally publish homegraph-ohos-api-db-<version> (one npm package per API version).
+ *
+ * Usage:
+ *   node scripts/ohos-sdk-publish.mjs <zip-or-dir> [version] [--dry-run] [--no-publish]
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import {
+  resolveOhosSdkInput,
+  ohosApiDbFilename,
+  ohosApiDbPackageName,
+  indexOhosApiDb,
+} from '../dist/extraction/languages/arkts.js';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function parseArgs(argv) {
+  const positional = [];
+  const flags = new Set();
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) flags.add(arg);
+    else positional.push(arg);
+  }
+  return {
+    input: positional[0] ?? '',
+    version: positional[1] ?? '',
+    dryRun: flags.has('--dry-run'),
+    noPublish: flags.has('--no-publish'),
+  };
+}
+
+function buildNpmPackage(version, dbPath, outDir) {
+  const dbName = ohosApiDbFilename(version);
+  const pkgName = ohosApiDbPackageName(version);
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(path.join(outDir, 'scripts'), { recursive: true });
+  fs.copyFileSync(dbPath, path.join(outDir, dbName));
+
+  const postinstall = `#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const dbName = ${JSON.stringify(dbName)};
+const src = path.join(__dirname, '..', dbName);
+const dest = path.join(os.homedir(), '.homegraph', 'api', dbName);
+if (!fs.existsSync(src)) process.exit(0);
+fs.mkdirSync(path.dirname(dest), { recursive: true });
+fs.copyFileSync(src, dest);
+`;
+  fs.writeFileSync(path.join(outDir, 'scripts', 'postinstall.js'), postinstall, { mode: 0o755 });
+  fs.writeFileSync(
+    path.join(outDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: pkgName,
+        version: '1.0.0',
+        description: `Prebuilt HomeGraph OHOS API database for SDK ${version}`,
+        license: 'MIT',
+        files: [dbName, 'scripts/postinstall.js'],
+        scripts: { postinstall: 'node scripts/postinstall.js' },
+        homegraph: { ohosApiVersion: version, dbFile: dbName },
+      },
+      null,
+      2
+    ) + '\n'
+  );
+  return pkgName;
+}
+
+const { input, version, dryRun, noPublish } = parseArgs(process.argv);
+if (!input) {
+  console.error('Usage: node scripts/ohos-sdk-publish.mjs <zip-or-dir> [version] [--dry-run] [--no-publish]');
+  process.exit(1);
+}
+
+if (!fs.existsSync(path.join(ROOT, 'dist/extraction/languages/arkts.js'))) {
+  console.error('[ohos-sdk-publish] dist not built — run npm run build first');
+  process.exit(1);
+}
+
+const resolved = resolveOhosSdkInput({
+  inputPath: path.resolve(input),
+  versionOverride: version || undefined,
+});
+
+const dbPath = path.join(
+  fs.mkdtempSync(path.join(path.dirname(resolved.sdkHome), '.hg-ohos-pack-')),
+  ohosApiDbFilename(resolved.version)
+);
+const pkgDir = path.join(path.dirname(dbPath), 'npm-package');
+
+try {
+  process.stderr.write(`[ohos-sdk-publish] indexing ${resolved.version} …\n`);
+  const result = await indexOhosApiDb({
+    sdkHome: resolved.sdkHome,
+    version: resolved.version,
+    outputPath: dbPath,
+    onProgress: (p) => {
+      if (p.phase === 'arkts-batch') {
+        const label = p.subphase === 'scene' ? 'Scene' : 'Persist';
+        process.stderr.write(`\r${label}: ${p.current}/${p.total}`.padEnd(40));
+      }
+    },
+  });
+  process.stderr.write('\n');
+  if (!result.success) {
+    for (const err of result.errors.filter((e) => e.severity === 'error')) console.error(err.message);
+    process.exit(1);
+  }
+
+  const pkgName = buildNpmPackage(resolved.version, dbPath, pkgDir);
+  console.log(`[ohos-sdk-publish] package: ${pkgName} → ${pkgDir} (${result.nodesCreated} nodes)`);
+
+  if (dryRun || noPublish) {
+    console.log('[ohos-sdk-publish] skipping npm publish');
+    process.exit(0);
+  }
+  if (!process.env.NPM_TOKEN) {
+    console.error('[ohos-sdk-publish] NPM_TOKEN not set — package built, not published');
+    process.exit(0);
+  }
+
+  const { execFileSync } = await import('child_process');
+  execFileSync('npm', ['publish', '--access', 'public'], { cwd: pkgDir, stdio: 'inherit' });
+  console.log(`[ohos-sdk-publish] published ${pkgName}`);
+} finally {
+  resolved.cleanup?.();
+}