@heart-of-gold/toolkit 0.1.3 → 0.1.5

package/README.md

@@ -17,6 +17,8 @@
 bunx @heart-of-gold/toolkit install --to codex
 ```
 
+The Codex target also applies Codex-specific wording transforms for flagship shared skills so interactive flows like `brainstorm` and `plan` more strongly encourage Codex's structured user-input UI instead of falling back to plain text when richer selection UX is available.
+
 ### OpenCode
 ```bash
 bunx @heart-of-gold/toolkit install --to opencode
@@ -24,16 +26,38 @@ bunx @heart-of-gold/toolkit install --to opencode
 
 ### Pi Coding Agent
 ```bash
+# Install shared skills into Pi's native skill directory
 bunx @heart-of-gold/toolkit install --to pi
+
+# Or install the package directly in Pi to get skills + pi-native extensions
+pi install npm:@heart-of-gold/toolkit
 ```
 
 Pi also discovers skills from the shared `~/.agents/skills/` location, so installs done with the OpenCode target are usable from Pi too.
 
+When installed as a Pi package, Heart of Gold also exposes pi-native enhancement commands for flagship workflows:
+- `/hog-brainstorm` — guided brainstorm intake for the shared `brainstorm` skill
+- `/hog-plan` — planning mode entrypoint with pi-friendly tool defaults
+- `/hog-work` — execution mode entrypoint with stronger work guardrails
+
+For Pi, these flagship commands intentionally replace the direct shared-skill entries for `brainstorm`, `plan`, and `work` so the command palette stays clean and the Pi-native interactive flow is the default.
+
 ### List available skills
 ```bash
 bunx @heart-of-gold/toolkit list
 ```
 
+## Security & Trust
+
+Some skills in this repository can, when configured by the user, interact with personal services and local tooling such as:
+
+- Gmail and newsletter content
+- iMessage or Slack notifications
+- audio/image provider APIs
+- external URLs discovered in newsletters or prompts
+
+Treat skills and helper scripts as executable automation, not passive text. Review their contents before installing them, especially for plugins like **Guide** and **Babel Fish** that can access personal data or third-party services.
+
 ---
 
 ## The Five Plugins
@@ -125,6 +149,7 @@ The toolkit ships as an npm package with a CLI for installing skills into any su
 
 - `--to pi` installs to Pi's native `~/.pi/agent/skills/`
 - `--to opencode` installs to shared `~/.agents/skills/`, which Pi also discovers
+- `pi install npm:@heart-of-gold/toolkit` installs the package directly in Pi, including the shared skills plus pi-native extensions
 
 ```bash
 # Install all plugins into Codex
@@ -146,6 +171,20 @@ bunx @heart-of-gold/toolkit list deep-thought
 bunx @heart-of-gold/toolkit targets
 ```
 
+## Release Safety
+
+Before publishing to npm, run the safety checks:
+
+```bash
+npm run check:publish-safety
+npm run check:security
+npm run check:compat
+```
+
+- `check:publish-safety` verifies the `npm pack` file list and fails if the publish would include blocked files such as `.env` or obvious secrets such as private keys, Slack webhooks, GitHub tokens, npm tokens, or AWS access keys.
+- `check:security` runs lightweight regression checks for sensitive Guide scripts and is also enforced in GitHub Actions.
+- `check:compat` ensures the flagship shared skills (`brainstorm`, `plan`, `work`) keep their harness-neutral interaction contract rather than drifting toward pi-only or Claude-only assumptions.
+
 ## Requirements
 
 - **Codex/OpenCode/Pi**: Bun runtime (for `bunx`)

package/extensions/pi/brainstorm.ts

@@ -0,0 +1,67 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+function sendPrompt(pi: ExtensionAPI, prompt: string, ctx: Parameters<NonNullable<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>>[1]) {
+	if (ctx.isIdle()) {
+		pi.sendUserMessage(prompt);
+	} else {
+		pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+		ctx.ui.notify("Brainstorm prompt queued as follow-up", "info");
+	}
+}
+
+export default function brainstormExtension(pi: ExtensionAPI) {
+	pi.registerCommand("hog-brainstorm", {
+		description: "Interactive pi-first intake for the shared brainstorm skill",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/hog-brainstorm requires interactive mode", "warning");
+				return;
+			}
+
+			const topic = args.trim() || (await ctx.ui.editor("Brainstorm topic", ""))?.trim();
+			if (!topic) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			const clarity = await ctx.ui.select("How clear are the requirements right now?", [
+				"Unclear — need discovery",
+				"Partly clear — explore tradeoffs",
+				"Quite clear — validate before planning",
+			]);
+			if (!clarity) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			const goal = await ctx.ui.select("What should the brainstorm optimize for first?", [
+				"Find the right problem framing",
+				"Compare 2-3 viable approaches",
+				"Pressure-test the chosen direction",
+			]);
+			if (!goal) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			const prompt = [
+				`/skill:brainstorm ${topic}`,
+				"",
+				"Use a pi-friendly interactive flow:",
+				"- Ask one question at a time.",
+				"- Use explicit option lists whenever there are natural choices.",
+				"- Keep momentum high and avoid dumping questionnaires.",
+				"",
+				`Current clarity: ${clarity}`,
+				`Primary goal: ${goal}`,
+			].join("\n");
+
+			const theme = ctx.ui.theme;
+			ctx.ui.setStatus(
+				"hog-brainstorm",
+				theme.fg("accent", "◉") + theme.fg("dim", " Brainstorm flow active"),
+			);
+			sendPrompt(pi, prompt, ctx);
+		},
+	});
+}

package/extensions/pi/plan.ts

@@ -0,0 +1,94 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const PLAN_SAFE_TOOLS = ["read", "bash", "grep", "find", "ls"];
+
+export default function planExtension(pi: ExtensionAPI) {
+	let previousTools: string[] | null = null;
+
+	const applyPlanTools = () => {
+		const available = new Set(pi.getAllTools().map((tool) => tool.name));
+		const nextTools = PLAN_SAFE_TOOLS.filter((tool) => available.has(tool));
+		if (nextTools.length > 0) {
+			pi.setActiveTools(nextTools);
+		}
+	};
+
+	pi.registerCommand("hog-plan", {
+		description: "Interactive pi-first entrypoint for planning mode and the shared plan skill",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/hog-plan requires interactive mode", "warning");
+				return;
+			}
+
+			const source = args.trim() || (await ctx.ui.editor("Plan topic or brainstorm path", ""))?.trim();
+			if (!source) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			const mode = await ctx.ui.select("How should planning mode behave?", [
+				"Read-only planning (recommended)",
+				"Allow normal tools, but stay in planning mode",
+			]);
+			if (!mode) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			if (previousTools === null) {
+				previousTools = pi.getActiveTools();
+			}
+			if (mode.startsWith("Read-only")) {
+				applyPlanTools();
+			}
+
+			const prompt = [
+				`/skill:plan ${source}`,
+				"",
+				"Use a pi-friendly planning flow:",
+				"- Keep planning read-only unless the user explicitly exits planning mode.",
+				"- Ask one question at a time when clarification is needed.",
+				"- Use concise option lists when choosing between paths or handoffs.",
+			].join("\n");
+
+			const theme = ctx.ui.theme;
+			ctx.ui.setStatus(
+				"hog-plan",
+				theme.fg("accent", "◉") + theme.fg("dim", " Plan mode active"),
+			);
+
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Plan prompt queued as follow-up", "info");
+			}
+		},
+	});
+
+	pi.registerCommand("hog-execute", {
+		description: "Exit planning mode, restore tools, and optionally start work",
+		handler: async (args, ctx) => {
+			if (previousTools) {
+				pi.setActiveTools(previousTools);
+				previousTools = null;
+			}
+			ctx.ui.setStatus("hog-plan", "");
+
+			const target = args.trim();
+			if (!target) {
+				ctx.ui.notify("Planning mode cleared. Run /hog-work <plan-path> when ready.", "info");
+				return;
+			}
+
+			const prompt = `/skill:work ${target}`;
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Work prompt queued as follow-up", "info");
+			}
+		},
+	});
+}

package/extensions/pi/work.ts

@@ -0,0 +1,103 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const PROTECTED_PATHS = [".env", ".git/", "node_modules/"];
+const CONFIRM_COMMANDS = [/\bgit\s+push\b/i, /\bnpm\s+publish\b/i, /\bbun\s+publish\b/i, /\bgh\s+pr\s+create\b/i];
+const BLOCKED_COMMANDS = [/\bgit\s+add\s+\.\b/i, /\brm\s+(-rf?|--recursive)/i];
+
+export default function workExtension(pi: ExtensionAPI) {
+	let workMode = false;
+
+	pi.registerCommand("hog-work", {
+		description: "Interactive pi-first entrypoint for the shared work skill",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/hog-work requires interactive mode", "warning");
+				return;
+			}
+
+			const planPath = args.trim() || (await ctx.ui.editor("Plan path", ""))?.trim();
+			if (!planPath) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			const runMode = await ctx.ui.select("How strict should work mode be?", [
+				"Normal guardrails (recommended)",
+				"Strict guardrails for shipping work",
+			]);
+			if (!runMode) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			workMode = true;
+			const theme = ctx.ui.theme;
+			ctx.ui.setStatus(
+				"hog-work",
+				theme.fg("accent", "◉") + theme.fg("dim", ` Work mode active — ${runMode}`),
+			);
+
+			const prompt = [
+				`/skill:work ${planPath}`,
+				"",
+				"Use pi guardrails while executing:",
+				"- keep progress visible as tasks move from in-progress to complete",
+				"- do not use `git add .`",
+				"- confirm push/publish actions deliberately",
+				"- protect .env, .git/, and node_modules/ from accidental edits",
+			].join("\n");
+
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Work prompt queued as follow-up", "info");
+			}
+		},
+	});
+
+	pi.registerCommand("hog-work-off", {
+		description: "Disable Heart of Gold work-mode guardrails",
+		handler: async (_args, ctx) => {
+			workMode = false;
+			ctx.ui.setStatus("hog-work", "");
+			ctx.ui.notify("Work mode disabled", "info");
+		},
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!workMode) return undefined;
+
+		if (event.toolName === "write" || event.toolName === "edit") {
+			const path = String(event.input.path ?? "");
+			if (PROTECTED_PATHS.some((segment) => path.includes(segment))) {
+				if (ctx.hasUI) {
+					ctx.ui.notify(`Blocked protected path in work mode: ${path}`, "warning");
+				}
+				return { block: true, reason: `Protected path in work mode: ${path}` };
+			}
+		}
+
+		if (event.toolName !== "bash") return undefined;
+		const command = String(event.input.command ?? "");
+
+		if (BLOCKED_COMMANDS.some((pattern) => pattern.test(command))) {
+			return { block: true, reason: `Blocked unsafe command in work mode: ${command}` };
+		}
+
+		if (!CONFIRM_COMMANDS.some((pattern) => pattern.test(command))) {
+			return undefined;
+		}
+
+		if (!ctx.hasUI) {
+			return { block: true, reason: `Interactive confirmation required for: ${command}` };
+		}
+
+		const choice = await ctx.ui.select(`Confirm work-mode command:\n\n${command}`, ["Allow", "Block"]);
+		if (choice !== "Allow") {
+			return { block: true, reason: `Blocked by user: ${command}` };
+		}
+
+		return undefined;
+	});
+}

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "@heart-of-gold/toolkit",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Cross-platform installer for Heart of Gold skills — works with Codex, OpenCode, Pi, Claude Code, and more",
   "bin": {
     "heart-of-gold": "src/index.ts"
   },
+  "scripts": {
+    "check:publish-safety": "python3 scripts/check-publish-safety.py",
+    "check:security": "python3 scripts/check-security-regressions.py",
+    "check:compat": "python3 scripts/check-harness-compatibility.py",
+    "prepublishOnly": "npm run check:publish-safety && npm run check:compat"
+  },
   "dependencies": {
     "citty": "^0.1.6",
     "js-yaml": "^4.1.0"
@@ -25,11 +31,27 @@
     "claude-code",
     "opencode",
     "pi",
+    "pi-package",
     "ai-agents",
     "skills",
     "agents-md",
     "agentskills",
     "harness-engineering",
     "heart-of-gold"
-  ]
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/pi"
+    ],
+    "skills": [
+      "./plugins/*/skills",
+      "!./plugins/deep-thought/skills/brainstorm",
+      "!./plugins/deep-thought/skills/plan",
+      "!./plugins/marvin/skills/work"
+    ]
+  }
 }

package/plugins/babel-fish/README.md

@@ -5,6 +5,12 @@
 
 A media generation plugin for Claude Code. Turns text into audio content and generates images from prompts.
 
+## Security & Trust
+
+Babel Fish uses third-party media APIs when you enable its workflows. Review the skill instructions and helper scripts before use, and keep provider credentials in environment variables or local secret files outside the repository.
+
+Generated media may also be sent to external providers, so treat prompts and source material accordingly.
+
 ## Skills
 
 ### `/babel-fish:audio`

package/plugins/babel-fish/skills/visualize/SKILL.md

@@ -90,15 +90,23 @@ When invoked as `/visualize [path]`:
 
 ## Phase 1 — Render
 
+**IMPORTANT: Output the mind map in Claude's response text, NOT as bash tool output.**
+
+Claude Code's bash output panel truncates long output and wraps wide content, breaking alignment. Instead:
+
 1. Locate the renderer script (see above)
 2. Ensure dependencies are installed
-3. Run the renderer via bash:
+3. Run the renderer with `--no-color`, redirect to a temp file:
    ```bash
-   node "$SCRIPT" [options] [file]
+   node "$SCRIPT" --no-color [file] > /tmp/mindmap-result.txt 2>&1
    ```
-4. The output appears inline in the terminal with colors
+4. Read `/tmp/mindmap-result.txt`
+5. Output the contents inside a markdown fenced code block in your response text
+6. Clean up: `rm /tmp/mindmap-result.txt`
+
+The default mode is **vertical layout** — boxes on main branches, compact leaves, ~40 chars wide. Fits perfectly in Claude Code's response area.
 
-**Width:** Default is the terminal width (`$COLUMNS` or 120). For narrow terminals, use `--depth 1` to ensure readability.
+**For shell usage** (not through Claude Code): Run without `--no-color` for ANSI colors, or use `--horizontal` for the wide spatial layout.
 
 ## Phase 2 — Offer Next Steps
 

package/plugins/babel-fish/skills/visualize/scripts/render-mindmap/index.js

@@ -24,6 +24,7 @@ import { execSync } from 'child_process';
 import { parseMarkdown, parseJSON } from './parse.js';
 import { renderMindmap } from './render.js';
 import { renderCompact } from './compact.js';
+import { renderVertical } from './vertical.js';
 
 function main() {
   const args = process.argv.slice(2);
@@ -82,13 +83,20 @@ function main() {
   if (opts.compact) {
     const output = renderCompact(tree, { color: opts.color, maxDepth: opts.depth });
     console.log(output);
-  } else {
+  } else if (opts.horizontal) {
     const output = renderMindmap(tree, {
       maxWidth: opts.width,
       maxDepth: opts.depth,
       color: opts.color,
     });
     console.log(output);
+  } else {
+    // Default: vertical layout (fits narrow panels like Claude Code)
+    const output = renderVertical(tree, {
+      color: opts.color,
+      maxDepth: opts.depth,
+    });
+    console.log(output);
   }
 }
 
@@ -109,6 +117,7 @@ function parseArgs(args) {
     color: true,
     json: false,
     compact: false,
+    horizontal: false,
     html: false,
     htmlOutput: null,
   };
@@ -125,6 +134,8 @@ function parseArgs(args) {
       opts.json = true;
     } else if (arg === '--compact') {
       opts.compact = true;
+    } else if (arg === '--horizontal') {
+      opts.horizontal = true;
     } else if (arg === '--html') {
       opts.html = true;
       // Next arg might be output path (if it doesn't start with -)

package/plugins/babel-fish/skills/visualize/scripts/render-mindmap/vertical.js

@@ -0,0 +1,178 @@
+/**
+ * vertical.js — Vertical mind map renderer
+ *
+ * Renders a tree vertically (top-to-bottom flow, left-aligned).
+ * Root and depth-1 nodes get Unicode boxes. Deeper nodes use compact ├──/└── notation.
+ * Optimized for narrow output areas like Claude Code's response text.
+ *
+ * Width: ~40-60 chars. Height: unlimited (uses vertical space).
+ */
+
+import chalk from 'chalk';
+
+const BOX = {
+  topLeft: '╭', top: '─', topRight: '╮',
+  left: '│', right: '│',
+  bottomLeft: '╰', bottom: '─', bottomRight: '╯',
+};
+
+const DEPTH_COLORS = [
+  (t) => chalk.bold.cyan(t),           // root box border
+  (t) => chalk.green(t),               // depth 1 box border
+  (t) => chalk.yellow(t),              // depth 2 leaves
+  (t) => chalk.dim(t),                 // depth 3+
+];
+
+const LABEL_COLORS = [
+  (t) => chalk.bold.white(t),          // root label
+  (t) => chalk.bold.cyan(t),           // depth 1 label
+  (t) => chalk.green(t),               // depth 2 label
+  (t) => chalk.yellow(t),              // depth 3+ label
+];
+
+function colorBox(char, depth, useColor) {
+  if (!useColor) return char;
+  const fn = DEPTH_COLORS[Math.min(depth, DEPTH_COLORS.length - 1)];
+  return fn(char);
+}
+
+function colorLabel(text, depth, useColor) {
+  if (!useColor) return text;
+  const fn = LABEL_COLORS[Math.min(depth, LABEL_COLORS.length - 1)];
+  return fn(text);
+}
+
+function colorTree(char, depth, useColor) {
+  if (!useColor) return char;
+  const fn = DEPTH_COLORS[Math.min(depth, DEPTH_COLORS.length - 1)];
+  return fn(char);
+}
+
+/**
+ * Render a box around text.
+ * Returns array of lines.
+ */
+function renderBox(label, indent, depth, useColor) {
+  const pad = 2;
+  const innerWidth = label.length + pad * 2;
+  const topLine = colorBox(BOX.topLeft + BOX.top.repeat(innerWidth) + BOX.topRight, depth, useColor);
+  const midLine = colorBox(BOX.left, depth, useColor)
+    + ' '.repeat(pad) + colorLabel(label, depth, useColor) + ' '.repeat(pad)
+    + colorBox(BOX.right, depth, useColor);
+  const botLine = colorBox(BOX.bottomLeft + BOX.bottom.repeat(innerWidth) + BOX.bottomRight, depth, useColor);
+  return [
+    indent + topLine,
+    indent + midLine,
+    indent + botLine,
+  ];
+}
+
+/**
+ * Render the vertical mind map.
+ *
+ * @param {{ label: string, children: any[] }} tree
+ * @param {Object} [opts]
+ * @param {boolean} [opts.color=true]
+ * @param {number} [opts.maxDepth=Infinity]
+ * @param {number} [opts.boxDepth=1] — max depth for boxed nodes (deeper = compact)
+ * @returns {string}
+ */
+export function renderVertical(tree, opts = {}) {
+  const useColor = opts.color !== false;
+  const maxDepth = opts.maxDepth ?? Infinity;
+  const boxDepth = opts.boxDepth ?? 1;
+  const lines = [];
+
+  renderNode(lines, tree, '', true, 0, maxDepth, boxDepth, useColor, true);
+  return lines.join('\n');
+}
+
+function renderNode(lines, node, prefix, isLast, depth, maxDepth, boxDepth, useColor, isRoot) {
+  const label = node.label || '';
+  const children = node.children || [];
+
+  if (isRoot) {
+    // Root: centered box, no prefix
+    const boxLines = renderBox(label, '', depth, useColor);
+    lines.push(...boxLines);
+
+    if (children.length > 0) {
+      const connector = colorTree('  │', depth, useColor);
+      lines.push(connector);
+    }
+  } else if (depth <= boxDepth) {
+    // Boxed node: prefix + connector + box
+    const branch = isLast ? '└─' : '├─';
+    const cont = isLast ? '  ' : '│ ';
+
+    // Box with branch connector
+    const boxLines = renderBox(label, '', depth, useColor);
+    const branchChar = colorTree(prefix + branch, depth - 1, useColor);
+    lines.push(branchChar + boxLines[0]);
+    lines.push(colorTree(prefix + cont, depth - 1, useColor) + boxLines[1]);
+    lines.push(colorTree(prefix + cont, depth - 1, useColor) + boxLines[2]);
+
+    if (children.length > 0 && depth < maxDepth) {
+      lines.push(colorTree(prefix + cont + '  │', depth, useColor));
+    }
+  } else {
+    // Compact leaf: prefix + ├── label
+    const branch = isLast ? '└── ' : '├── ';
+    lines.push(colorTree(prefix + branch, depth - 1, useColor) + colorLabel(label, depth, useColor));
+  }
+
+  // Render children
+  if (depth >= maxDepth) {
+    if (children.length > 0) {
+      const cont = isRoot ? '  ' : (isLast ? '    ' : '│   ');
+      const childPrefix = isRoot ? '  ' : prefix + cont;
+      const hint = `+${children.length} more`;
+      lines.push(colorTree(childPrefix + '└── ', depth, useColor) + colorLabel(hint, depth + 1, useColor));
+    }
+    return;
+  }
+
+  const maxChildren = depth === 0 ? 8 : (depth <= boxDepth ? 6 : 5);
+  let visibleChildren = children;
+  let overflow = 0;
+
+  if (children.length > maxChildren) {
+    overflow = children.length - maxChildren + 1;
+    visibleChildren = children.slice(0, maxChildren - 1);
+  }
+
+  for (let i = 0; i < visibleChildren.length; i++) {
+    const child = visibleChildren[i];
+    const childIsLast = (i === visibleChildren.length - 1) && overflow === 0;
+
+    let childPrefix;
+    if (isRoot) {
+      childPrefix = '  ';
+    } else if (depth <= boxDepth) {
+      childPrefix = prefix + (isLast ? '  ' : '│ ') + '  ';
+    } else {
+      childPrefix = prefix + (isLast ? '    ' : '│   ');
+    }
+
+    renderNode(lines, child, childPrefix, childIsLast, depth + 1, maxDepth, boxDepth, useColor, false);
+
+    // Add spacing between boxed siblings (not after last)
+    if (depth + 1 <= boxDepth && !childIsLast) {
+      const cont = isRoot ? '  │' : prefix + (isLast ? '  ' : '│ ') + '  │';
+      lines.push(colorTree(cont, depth, useColor));
+    }
+  }
+
+  if (overflow > 0) {
+    let childPrefix;
+    if (isRoot) {
+      childPrefix = '  ';
+    } else if (depth <= boxDepth) {
+      childPrefix = prefix + (isLast ? '  ' : '│ ') + '  ';
+    } else {
+      childPrefix = prefix + (isLast ? '    ' : '│   ');
+    }
+    const hint = `+${overflow} more`;
+    lines.push(colorTree(childPrefix + '└── ', depth, useColor) + colorLabel(hint, depth + 1, useColor));
+  }
+}