homegraph 1.1.2 → 1.2.0

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/extract-release-notes.mjs

@@ -1,130 +1,130 @@
-#!/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');
+#!/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');