xtrm-tools 0.7.3 → 0.7.7

package/.xtrm/ext-src/xtrm-ui/format.ts

@@ -0,0 +1,282 @@
+export interface DiffStats {
+  additions: number;
+  removals: number;
+}
+
+// pi-diff compatibility adapter:
+// @heyhuynhgiabuu/pi-diff currently exposes extension-first entrypoints
+// (no stable library export surface), so xtrm-ui vendors this renderer to
+// keep write/edit previews deterministic while preserving single-wrapper ownership.
+interface DiffTheme {
+  fg(color: string, text: string): string;
+  bold?(text: string): string;
+}
+
+interface HunkCursor {
+  oldLine: number;
+  newLine: number;
+}
+
+export function shortenHome(path: string): string {
+  const home = process.env.HOME;
+  if (home && path.startsWith(home)) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+export function shortenPath(path: string, max = 56): string {
+  const normalized = shortenHome(path);
+  if (normalized.length <= max) return normalized;
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length <= 2) return `…${normalized.slice(-(max - 1))}`;
+  const tail = parts.slice(-2).join("/");
+  const head = parts[0]?.startsWith("~") ? "~/" : "…/";
+  const candidate = `${head}${tail}`;
+  if (candidate.length <= max) return candidate;
+  return `…${candidate.slice(-(max - 1))}`;
+}
+
+export function shortenCommand(command: string, max = 72): string {
+  const singleLine = command.replace(/\s+/g, " ").trim();
+  if (singleLine.length <= max) return singleLine;
+  return `${singleLine.slice(0, Math.max(0, max - 1))}…`;
+}
+
+export function lineCount(text: string): number {
+  if (!text) return 0;
+  return text.split("\n").length;
+}
+
+export function previewLines(text: string, count: number): string[] {
+  return text.split("\n").slice(0, count);
+}
+
+export function cleanOutputLines(text: string): string[] {
+  return text
+    .split("\n")
+    .filter((line) => line.trim().length > 0)
+    .filter((line) => !/^exit code:\s*-?\d+$/i.test(line.trim()));
+}
+
+export function countPrefixedItems(text: string, prefixes: string[]): number {
+  return text.split("\n").filter((line) => prefixes.some((prefix) => line.startsWith(prefix))).length;
+}
+
+export function diffStats(diff: string): DiffStats {
+  let additions = 0;
+  let removals = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+    if (line.startsWith("-") && !line.startsWith("---")) removals++;
+  }
+  return { additions, removals };
+}
+
+export function createUnifiedLineDiff(oldContent: string, newContent: string): string {
+  if (oldContent === newContent) return "";
+
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const out: string[] = ["--- a/file", "+++ b/file", `@@ -1,${oldLines.length} +1,${newLines.length} @@`];
+
+  let oldIndex = 0;
+  let newIndex = 0;
+
+  while (oldIndex < oldLines.length || newIndex < newLines.length) {
+    const oldLine = oldLines[oldIndex];
+    const newLine = newLines[newIndex];
+
+    if (oldLine === newLine) {
+      out.push(` ${oldLine ?? ""}`);
+      oldIndex++;
+      newIndex++;
+      continue;
+    }
+
+    if (oldIndex + 1 < oldLines.length && oldLines[oldIndex + 1] === newLine) {
+      out.push(`-${oldLine ?? ""}`);
+      oldIndex++;
+      continue;
+    }
+
+    if (newIndex + 1 < newLines.length && oldLine === newLines[newIndex + 1]) {
+      out.push(`+${newLine ?? ""}`);
+      newIndex++;
+      continue;
+    }
+
+    if (oldIndex < oldLines.length) {
+      out.push(`-${oldLine ?? ""}`);
+      oldIndex++;
+    }
+    if (newIndex < newLines.length) {
+      out.push(`+${newLine ?? ""}`);
+      newIndex++;
+    }
+  }
+
+  return out.join("\n");
+}
+
+function parseHunkHeader(line: string): HunkCursor | undefined {
+  const match = line.match(/^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/);
+  if (!match) return undefined;
+  return {
+    oldLine: Number.parseInt(match[1] ?? "1", 10),
+    newLine: Number.parseInt(match[2] ?? "1", 10),
+  };
+}
+
+function renderLineNumbers(theme: DiffTheme, oldLine: number | null, newLine: number | null): string {
+  const format = (value: number | null) => (value == null ? "    " : String(value).padStart(4, " "));
+  return theme.fg("muted", `${format(oldLine)} ${format(newLine)} │`);
+}
+
+function safeBold(theme: DiffTheme, text: string): string {
+  return theme.bold ? theme.bold(text) : text;
+}
+
+function splitChangedSegment(before: string, after: string): { before: string; beforeMid: string; beforeTail: string; after: string; afterMid: string; afterTail: string } {
+  let prefixLength = 0;
+  const minLength = Math.min(before.length, after.length);
+
+  while (prefixLength < minLength && before[prefixLength] === after[prefixLength]) {
+    prefixLength++;
+  }
+
+  let suffixLength = 0;
+  while (
+    suffixLength < minLength - prefixLength &&
+    before[before.length - 1 - suffixLength] === after[after.length - 1 - suffixLength]
+  ) {
+    suffixLength++;
+  }
+
+  return {
+    before: before.slice(0, prefixLength),
+    beforeMid: before.slice(prefixLength, before.length - suffixLength),
+    beforeTail: before.slice(before.length - suffixLength),
+    after: after.slice(0, prefixLength),
+    afterMid: after.slice(prefixLength, after.length - suffixLength),
+    afterTail: after.slice(after.length - suffixLength),
+  };
+}
+
+function renderWordHighlightedPair(theme: DiffTheme, removed: string, added: string): { removed: string; added: string } {
+  const segments = splitChangedSegment(removed, added);
+  const removedContent = `${segments.before}${segments.beforeMid ? safeBold(theme, segments.beforeMid) : ""}${segments.beforeTail}`;
+  const addedContent = `${segments.after}${segments.afterMid ? safeBold(theme, segments.afterMid) : ""}${segments.afterTail}`;
+
+  return {
+    removed: theme.fg("toolDiffRemoved", `-${removedContent}`),
+    added: theme.fg("toolDiffAdded", `+${addedContent}`),
+  };
+}
+
+export function renderRichDiffPreview(theme: DiffTheme, diff: string, maxLines: number): string {
+  const lines = diff.split("\n");
+  const rendered: string[] = [];
+  let shown = 0;
+  let oldLine = 1;
+  let newLine = 1;
+
+  for (let index = 0; index < lines.length && shown < maxLines; index++) {
+    const line = lines[index] ?? "";
+
+    if (line.startsWith("@@")) {
+      const cursor = parseHunkHeader(line);
+      if (cursor) {
+        oldLine = cursor.oldLine;
+        newLine = cursor.newLine;
+      }
+      rendered.push(`${renderLineNumbers(theme, null, null)} ${theme.fg("muted", line)}`);
+      shown++;
+      continue;
+    }
+
+    if (line.startsWith("---") || line.startsWith("+++")) {
+      rendered.push(`${renderLineNumbers(theme, null, null)} ${theme.fg("toolDiffContext", line)}`);
+      shown++;
+      continue;
+    }
+
+    if (line.startsWith("-") && !line.startsWith("---") && shown + 1 <= maxLines) {
+      const nextLine = lines[index + 1] ?? "";
+      if (nextLine.startsWith("+") && !nextLine.startsWith("+++")) {
+        const pair = renderWordHighlightedPair(theme, line.slice(1), nextLine.slice(1));
+        rendered.push(`${renderLineNumbers(theme, oldLine, null)} ${pair.removed}`);
+        rendered.push(`${renderLineNumbers(theme, null, newLine)} ${pair.added}`);
+        oldLine++;
+        newLine++;
+        index++;
+        shown += 2;
+        continue;
+      }
+    }
+
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      rendered.push(`${renderLineNumbers(theme, oldLine, null)} ${theme.fg("toolDiffRemoved", line)}`);
+      oldLine++;
+      shown++;
+      continue;
+    }
+
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      rendered.push(`${renderLineNumbers(theme, null, newLine)} ${theme.fg("toolDiffAdded", line)}`);
+      newLine++;
+      shown++;
+      continue;
+    }
+
+    if (line.startsWith(" ")) {
+      rendered.push(`${renderLineNumbers(theme, oldLine, newLine)} ${theme.fg("toolDiffContext", line)}`);
+      oldLine++;
+      newLine++;
+      shown++;
+      continue;
+    }
+
+    rendered.push(`${renderLineNumbers(theme, null, null)} ${theme.fg("toolDiffContext", line)}`);
+    shown++;
+  }
+
+  if (lines.length > shown) {
+    rendered.push(theme.fg("muted", `     … +${lines.length - shown} more`));
+  }
+
+  return rendered.join("\n");
+}
+
+export function formatDuration(durationMs: number | undefined): string | undefined {
+  if (!durationMs || durationMs < 0) return undefined;
+  if (durationMs < 1000) return `${durationMs}ms`;
+  const seconds = durationMs / 1000;
+  if (seconds < 10) return `${seconds.toFixed(1)}s`;
+  return `${Math.round(seconds)}s`;
+}
+
+export function formatLineLabel(count: number, noun: string): string {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+
+export function renderToolSummary(
+  theme: { fg(color: string, text: string): string; bold(text: string): string },
+  status: "pending" | "success" | "error" | "muted",
+  label: string,
+  subject?: string,
+  meta?: string,
+): string {
+  const color =
+    status === "pending" ? "accent"
+    : status === "error" ? "error"
+    : status === "success" ? "success"
+    : "muted";
+  let text = `${theme.fg(color, "•")} ${theme.fg("toolTitle", theme.bold(label))}`;
+  if (subject) text += ` ${theme.fg("accent", subject)}`;
+  if (meta) text += theme.fg("muted", ` · ${meta}`);
+  return text;
+}
+
+export function joinMeta(parts: Array<string | undefined | false>): string | undefined {
+  const filtered = parts.filter((part): part is string => typeof part === "string" && part.length > 0);
+  return filtered.length > 0 ? filtered.join(" · ") : undefined;
+}

package/.xtrm/{extensions → ext-src}/xtrm-ui/index.ts

@@ -32,16 +32,19 @@ import {
   createWriteTool,
 } from "@mariozechner/pi-coding-agent";
 import { Box, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { existsSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import {
   cleanOutputLines,
   countPrefixedItems,
+  createUnifiedLineDiff,
   diffStats,
   formatDuration,
   formatLineLabel,
   joinMeta,
   lineCount,
   previewLines,
+  renderRichDiffPreview,
   renderToolSummary,
   shortenCommand,
   shortenPath,
@@ -237,19 +240,6 @@ function renderVerticalPreview(theme: any, lines: string[], maxLines: number): s
   return text;
 }
 
-function renderDiffPreview(theme: any, diff: string, maxLines: number): string {
-  const lines = diff.split("\n").slice(0, maxLines);
-  let out = "";
-  for (const line of lines) {
-    const styled =
-      line.startsWith("+") && !line.startsWith("+++") ? theme.fg("toolDiffAdded", `  ${line}`)
-      : line.startsWith("-") && !line.startsWith("---") ? theme.fg("toolDiffRemoved", `  ${line}`)
-      : theme.fg("toolDiffContext", `  ${line}`);
-    out += (out ? "\n" : "") + styled;
-  }
-  if (diff.split("\n").length > maxLines) out += `\n${theme.fg("muted", `  … +${diff.split("\n").length - maxLines} more`)}`;
-  return out;
-}
 
 function lineRange(offset?: number, limit?: number): string | undefined {
   if (offset == null && limit == null) return undefined;
@@ -436,8 +426,14 @@ type XtrmMeta<TArgs = Record<string, unknown>> = {
   durationMs: number;
 };
 
+type XtrmWritePreview =
+  | { kind: "created"; lineCount: number }
+  | { kind: "updated"; diff: string; additions: number; removals: number }
+  | { kind: "unchanged" };
+
 type DetailsWithXtrmMeta<TDetails, TArgs = Record<string, unknown>> = TDetails & {
   xtrmMeta?: XtrmMeta<TArgs>;
+  xtrmWritePreview?: XtrmWritePreview;
 };
 
 const toolCache = new Map<string, BuiltInTools>();
@@ -484,6 +480,30 @@ function getTextContent(result: { content: Array<{ type: string; text?: string }
   return item?.text ?? "";
 }
 
+function createWritePreview(path: string, nextContent: string): XtrmWritePreview {
+  if (!path || !existsSync(path)) {
+    return { kind: "created", lineCount: lineCount(nextContent) };
+  }
+
+  let currentContent = "";
+  try {
+    currentContent = readFileSync(path, "utf8");
+  } catch {
+    return { kind: "created", lineCount: lineCount(nextContent) };
+  }
+
+  if (currentContent === nextContent) return { kind: "unchanged" };
+
+  const diff = createUnifiedLineDiff(currentContent, nextContent);
+  const stats = diffStats(diff);
+  return {
+    kind: "updated",
+    diff,
+    additions: stats.additions,
+    removals: stats.removals,
+  };
+}
+
 function renderPendingCall(toolName: string, args: Record<string, unknown>, theme: any): Text {
   return new Text(renderToolSummary(theme, "pending", toolName, summarizeToolSubject(toolName, args), undefined), 0, 0);
 }
@@ -859,7 +879,7 @@ function registerXtrmUiTools(pi: ExtensionAPI): void {
       }
       const stats = details.diff ? diffStats(details.diff) : { additions: 0, removals: 0 };
       let text = renderToolSummary(theme, "success", "edit", shortenPath(String(meta?.args.path ?? "")), joinMeta([`+${stats.additions}`, `-${stats.removals}`, formatDuration(meta?.durationMs)]));
-      if (expanded && details.diff) text += `\n${renderDiffPreview(theme, details.diff, 18)}`;
+      if (expanded && details.diff) text += `\n${renderRichDiffPreview(theme, details.diff, 18)}`;
       return new Text(text, 0, 0);
     },
   });
@@ -871,11 +891,16 @@ function registerXtrmUiTools(pi: ExtensionAPI): void {
     parameters: getTools(process.cwd()).write.parameters,
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       const started = Date.now();
+      const args = params as Record<string, unknown>;
+      const path = String(args.path ?? "");
+      const content = String(args.content ?? "");
+      const preview = createWritePreview(path, content);
       const result = await getTools(ctx.cwd).write.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as Record<string, never> | undefined, "write", params as Record<string, unknown>, Date.now() - started) };
+      const details = withXtrmMeta(result.details as Record<string, never> | undefined, "write", args, Date.now() - started);
+      return { ...result, details: { ...details, xtrmWritePreview: preview } };
     },
     renderCall: (args, theme) => renderPendingCallIfActive("write", args as Record<string, unknown>, theme),
-    renderResult(result, { isPartial }, theme) {
+    renderResult(result, { expanded, isPartial }, theme) {
       if (isPartial) return new Text(renderToolSummary(theme, "pending", "write", "writing", undefined), 0, 0);
       const details = (result.details ?? {}) as DetailsWithXtrmMeta<Record<string, never>, Record<string, unknown>>;
       const meta = getXtrmMeta<Record<string, never>, Record<string, unknown>>(details);
@@ -883,7 +908,41 @@ function registerXtrmUiTools(pi: ExtensionAPI): void {
       if (/^error/i.test(textContent.trim())) {
         return new Text(renderToolSummary(theme, "error", "write", shortenPath(String(meta?.args.path ?? "")), textContent.split("\n")[0]), 0, 0);
       }
-      return new Text(renderToolSummary(theme, "success", "write", shortenPath(String(meta?.args.path ?? "")), joinMeta([formatLineLabel(lineCount(String(meta?.args.content ?? "")), "line"), formatDuration(meta?.durationMs)])), 0, 0);
+
+      const subject = shortenPath(String(meta?.args.path ?? ""));
+      const preview = details.xtrmWritePreview;
+
+      if (preview?.kind === "unchanged") {
+        return new Text(renderToolSummary(theme, "success", "write", subject, joinMeta(["no changes", formatDuration(meta?.durationMs)])), 0, 0);
+      }
+
+      if (preview?.kind === "updated") {
+        let text = renderToolSummary(
+          theme,
+          "success",
+          "write",
+          subject,
+          joinMeta([`+${preview.additions}`, `-${preview.removals}`, formatDuration(meta?.durationMs)]),
+        );
+        if (expanded && preview.diff) text += `\n${renderRichDiffPreview(theme, preview.diff, 18)}`;
+        return new Text(text, 0, 0);
+      }
+
+      const lines = preview?.kind === "created"
+        ? preview.lineCount
+        : lineCount(String(meta?.args.content ?? ""));
+
+      return new Text(
+        renderToolSummary(
+          theme,
+          "success",
+          "write",
+          subject,
+          joinMeta([formatLineLabel(lines, "line"), formatDuration(meta?.durationMs)]),
+        ),
+        0,
+        0,
+      );
     },
   });
 

package/.xtrm/ext-src/xtrm-ui/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@xtrm/pi-xtrm-ui",
+  "version": "1.1.0",
+  "description": "XTRM UI: pi-dex chrome + pi-diff style write/edit rendering with custom-footer-safe ownership",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@heyhuynhgiabuu/pi-diff": "^0.2.1"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "themes": [
+      "./themes"
+    ]
+  }
+}

package/.xtrm/hooks/specialists/specialists-complete.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// specialists-complete — Claude Code UserPromptSubmit/PostToolUse hook
+// Checks .specialists/ready/ for completed background job markers and injects
+// completion/failure banners into Claude's context.
+//
+// Installed by: specialists install
+
+import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+
+const cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+const readyDir = join(cwd, '.specialists', 'ready');
+
+// Exit silently if no ready dir or nothing to report
+if (!existsSync(readyDir)) process.exit(0);
+
+let markers;
+try {
+  markers = readdirSync(readyDir).filter(f => !f.startsWith('.'));
+} catch {
+  process.exit(0);
+}
+
+if (markers.length === 0) process.exit(0);
+
+const banners = [];
+
+for (const jobId of markers) {
+  const markerPath = join(readyDir, jobId);
+  const statusPath = join(cwd, '.specialists', 'jobs', jobId, 'status.json');
+
+  try {
+    let specialist = jobId;
+    let elapsed = '';
+    let completionStatus = 'done';
+    let errorMessage = '';
+
+    if (existsSync(statusPath)) {
+      const status = JSON.parse(readFileSync(statusPath, 'utf-8'));
+      specialist = status.specialist ?? jobId;
+      elapsed = status.elapsed_s !== undefined ? `, ${status.elapsed_s}s` : '';
+      completionStatus = status.status ?? 'done';
+      errorMessage = status.error ? ` — ${status.error}` : '';
+    }
+
+    if (completionStatus === 'error') {
+      banners.push(
+        `[Specialist '${specialist}' failed (job ${jobId}${elapsed}${errorMessage}). Run: specialists feed ${jobId} --follow]`
+      );
+    } else {
+      banners.push(
+        `[Specialist '${specialist}' completed (job ${jobId}${elapsed}). Run: specialists result ${jobId}]`
+      );
+    }
+
+    // Delete marker so it only fires once
+    unlinkSync(markerPath);
+  } catch {
+    // Ignore malformed entries
+    try { unlinkSync(markerPath); } catch { /* ignore */ }
+  }
+}
+
+if (banners.length === 0) process.exit(0);
+
+// UserPromptSubmit/PostToolUse hooks inject content via JSON
+process.stdout.write(JSON.stringify({
+  type: 'inject',
+  content: banners.join('\n'),
+}) + '\n');

package/.xtrm/hooks/specialists/specialists-session-start.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// specialists-session-start — Claude Code SessionStart hook
+// Injects specialists context at the start of every session:
+//   • Active background jobs (if any)
+//   • Available specialists list
+//   • Key CLI commands reminder
+//
+// Installed by: specialists init
+// Hook type: SessionStart
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const cwd     = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+const HOME    = homedir();
+const jobsDir = join(cwd, '.specialists', 'jobs');
+const lines   = [];
+
+// ── 1. Active background jobs ──────────────────────────────────────────────
+if (existsSync(jobsDir)) {
+  let entries = [];
+  try { entries = readdirSync(jobsDir); } catch { /* ignore */ }
+
+  const activeJobs = [];
+  for (const jobId of entries) {
+    const statusPath = join(jobsDir, jobId, 'status.json');
+    if (!existsSync(statusPath)) continue;
+    try {
+      const s = JSON.parse(readFileSync(statusPath, 'utf-8'));
+      if (s.status === 'running' || s.status === 'starting') {
+        const elapsed = s.elapsed_s !== undefined ? ` (${s.elapsed_s}s)` : '';
+        activeJobs.push(
+          `  • ${s.specialist ?? jobId}  [${s.status}]${elapsed}  →  specialists result ${jobId}`
+        );
+      }
+    } catch { /* malformed status.json */ }
+  }
+
+  if (activeJobs.length > 0) {
+    lines.push('## Specialists — Active Background Jobs');
+    lines.push('');
+    lines.push(...activeJobs);
+    lines.push('');
+    lines.push('Use `specialists feed <job-id> --follow` to stream events, or `specialists result <job-id>` when done.');
+    lines.push('');
+  }
+}
+
+// ── 2. Available specialists (read YAML dirs directly) ────────────────────
+function readSpecialistNames(dir) {
+  if (!existsSync(dir)) return [];
+  try {
+    return readdirSync(dir)
+      .filter(f => f.endsWith('.specialist.yaml'))
+      .map(f => f.replace('.specialist.yaml', ''));
+  } catch {
+    return [];
+  }
+}
+
+const projectNames = readSpecialistNames(join(cwd, 'specialists'));
+const userNames    = readSpecialistNames(join(HOME, '.agents', 'specialists'));
+
+// Merge, deduplicate, sort
+const allNames = [...new Set([...projectNames, ...userNames])].sort();
+
+if (allNames.length > 0) {
+  lines.push('## Specialists — Available');
+  lines.push('');
+  if (projectNames.length > 0) {
+    lines.push(`project (${projectNames.length}): ${projectNames.join(', ')}`);
+  }
+  if (userNames.length > 0) {
+    // Only show user-scope names not already in project
+    const extraUser = userNames.filter(n => !projectNames.includes(n));
+    if (extraUser.length > 0) {
+      lines.push(`user    (${extraUser.length}): ${extraUser.join(', ')}`);
+    }
+  }
+  lines.push('');
+}
+
+// ── 3. Key commands reminder ───────────────────────────────────────────────
+lines.push('## Specialists — Session Quick Reference');
+lines.push('');
+lines.push('```');
+lines.push('specialists list                                   # discover available specialists');
+lines.push('specialists run <name> --prompt "..."              # run foreground (streams output)');
+lines.push('specialists run <name> --prompt "..."              # run; job ID prints on stderr');
+lines.push('specialists feed <job-id> --follow                 # tail live events');
+lines.push('specialists result <job-id>                        # read final output');
+lines.push('specialists status                                 # system health');
+lines.push('specialists doctor                                 # troubleshoot issues');
+lines.push('```');
+lines.push('');
+lines.push('MCP tools: use_specialist (foreground only)');
+
+// ── Output ─────────────────────────────────────────────────────────────────
+if (lines.length === 0) process.exit(0);
+
+process.stdout.write(JSON.stringify({
+  type: 'inject',
+  content: lines.join('\n'),
+}) + '\n');