lazyclaude-ai 0.1.7 → 0.1.9

package/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 
-## 0.1.7 - Unreleased
+## 0.1.9 - Unreleased
+
+- Install a LazyClaude-branded Claude Code statusLine HUD automatically during
+  `lazyclaude install`, with safe previous-statusLine restoration on uninstall.
+
+## 0.1.8
+
+- Teach `lazyclaude doctor` to separate LazyClaude's own LSP declaration from
+  external Claude Code LSP plugin binary warnings.
+
+## 0.1.7
 
 - Expand the LazyCodex port audit beyond skill frontmatter into upstream OMO
   component coverage.

package/README.md

@@ -9,7 +9,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-lazyclaude--ai-cb3837" />
-  <img src="https://img.shields.io/badge/version-0.1.7-2ea44f" />
+  <img src="https://img.shields.io/badge/version-0.1.9-2ea44f" />
   <img src="https://img.shields.io/badge/Claude%20Code-plugin-blueviolet" />
   <img src="https://img.shields.io/badge/license-MIT-blue" />
 </p>
@@ -19,7 +19,7 @@
 > [!NOTE]
 > LazyClaude is a quiet personal distribution for bringing LazyCodex-style prompt engineering into Claude Code. It installs as `lazyclaude@lazyclaude-ai`, so normal `claude` launches can load the LazyClaude skills and hooks without a long `--plugin-dir` command.
 
-This checkout is prepared as `lazyclaude-ai@0.1.7` for personal install
+This checkout is prepared as `lazyclaude-ai@0.1.9` for personal install
 convenience. The repo can remain private and quiet; publishing to npm here does
 not imply public repo promotion, marketplace publication, or advertisement.
 Future package releases still require explicit user approval.
@@ -44,6 +44,8 @@ Future package releases still require explicit user approval.
 - **Workflow agents** - planner, executor, verifier, reviewer, librarian, and QA runner
 - **Local marketplace registration** - Claude can resolve `claude plugin details lazyclaude@lazyclaude-ai`
 - **MCP and LSP helpers** - plugin-local stdio MCP plus TypeScript-family LSP doctor
+- **LazyClaude HUD** - npm install configures a compact Claude Code statusLine
+  based on `pretty-claude-hud`, branded as `[LAZYCLAUDE vX.Y.Z]`
 - **Safe uninstall** - removes only LazyClaude-managed state
 
 ## Quick Start
@@ -55,14 +57,14 @@ npx --yes lazyclaude-ai install
 ```
 
 If you are currently inside this repository checkout, which has the same
-package name as the registry package, `npx --yes lazyclaude-ai@0.1.7 install`
+package name as the registry package, `npx --yes lazyclaude-ai@0.1.9 install`
 can resolve the local same-name source checkout and fail with
 `sh: lazyclaude-ai: command not found`. From a fresh directory, the normal
 install command works:
 
 ```bash
 cd /tmp
-npx --yes lazyclaude-ai@0.1.7 install
+npx --yes lazyclaude-ai@0.1.9 install
 ```
 
 Validate the installed plugin:
@@ -71,6 +73,13 @@ Validate the installed plugin:
 npx --yes lazyclaude-ai doctor
 ```
 
+The installer also sets Claude Code's `statusLine` command to the packaged
+LazyClaude HUD. A typical no-color render starts like:
+
+```text
+[LAZYCLAUDE v0.1.9] | O4.8 │ ctx ▄░░░░░ 9%/1000k │ 5h [░░░░░]4% │ 1w [█░░░░]35% │ git main +3 ✓
+```
+
 Launch Claude Code normally:
 
 ```bash

package/README_ko-KR.md

@@ -9,7 +9,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-lazyclaude--ai-cb3837" />
-  <img src="https://img.shields.io/badge/version-0.1.7-2ea44f" />
+  <img src="https://img.shields.io/badge/version-0.1.9-2ea44f" />
   <img src="https://img.shields.io/badge/Claude%20Code-plugin-blueviolet" />
   <img src="https://img.shields.io/badge/license-MIT-blue" />
 </p>
@@ -23,7 +23,7 @@
 > [!NOTE]
 > LazyClaude는 LazyCodex 스타일의 prompt engineering을 Claude Code로 가져오기 위한 조용한 개인용 배포판입니다. `lazyclaude@lazyclaude-ai`로 설치되므로, 매번 긴 `--plugin-dir` 없이 일반 `claude` 실행에서 LazyClaude skill과 hook을 불러올 수 있습니다.
 
-현재 checkout은 `lazyclaude-ai@0.1.7` 배포용으로 준비되어 있습니다. 목적은 다른 PC에서도
+현재 checkout은 `lazyclaude-ai@0.1.9` 배포용으로 준비되어 있습니다. 목적은 다른 PC에서도
 빠르게 설치하기 위한 개인용 배포물입니다. 저장소는 비공개 저장소로
 유지할 수 있고, npm 배포가 곧 홍보, 공개 저장소 운영, Claude marketplace
 등록을 의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
@@ -48,6 +48,8 @@
 - **워크플로우 agents** - planner, executor, verifier, reviewer, librarian, QA runner
 - **Local marketplace 등록** - `claude plugin details lazyclaude@lazyclaude-ai`에서 inventory 확인
 - **MCP와 LSP helper** - plugin-local stdio MCP와 TypeScript 계열 LSP doctor
+- **LazyClaude HUD** - npm install 시 `pretty-claude-hud` 기반의 compact
+  Claude Code statusLine을 `[LAZYCLAUDE vX.Y.Z]` 브랜드로 자동 설정
 - **안전한 uninstall** - LazyClaude가 관리한 상태만 제거
 
 ## 빠른 시작
@@ -60,13 +62,13 @@ npx --yes lazyclaude-ai install
 
 현재 위치가 이 저장소 checkout이면, registry package와 같은 package name을
 가진 same-name source checkout 안에 있는 상태입니다. 이 경우
-`npx --yes lazyclaude-ai@0.1.7 install`이 local checkout을 먼저 해석해서
+`npx --yes lazyclaude-ai@0.1.9 install`이 local checkout을 먼저 해석해서
 `sh: lazyclaude-ai: command not found`로 실패할 수 있습니다. 새 폴더에서는
 일반 설치 명령이 정상 동작합니다.
 
 ```bash
 cd /tmp
-npx --yes lazyclaude-ai@0.1.7 install
+npx --yes lazyclaude-ai@0.1.9 install
 ```
 
 설치 상태를 확인합니다.
@@ -75,6 +77,13 @@ npx --yes lazyclaude-ai@0.1.7 install
 npx --yes lazyclaude-ai doctor
 ```
 
+installer는 Claude Code의 `statusLine` command도 packaged LazyClaude HUD로
+설정합니다. 색상을 제거한 예시는 다음처럼 시작합니다.
+
+```text
+[LAZYCLAUDE v0.1.9] | O4.8 │ ctx ▄░░░░░ 9%/1000k │ 5h [░░░░░]4% │ 1w [█░░░░]35% │ git main +3 ✓
+```
+
 설치 후에는 일반적인 `claude` 명령으로 Claude Code를 실행합니다.
 
 ```bash

package/RELEASE_CHECKLIST.md

@@ -1,7 +1,7 @@
 # LazyClaude Release Checklist
 
 Status: this checkout is prepared for quiet public npm package
-`lazyclaude-ai@0.1.7` after explicit user approval.
+`lazyclaude-ai@0.1.9` after explicit user approval.
 
 DO NOT publish a new version of LazyClaude, run `npm publish`, push release
 tags, or add a remote Claude Code marketplace entry without explicit user
@@ -44,7 +44,7 @@ to type a generated command that shells out to `npx --yes lazyclaude-ai path` fo
 normal npm installs.
 
 Run fresh-machine QA from a fresh directory, not from this repository checkout.
-Inside the same-name source checkout, `npx --yes lazyclaude-ai@0.1.7 install`
+Inside the same-name source checkout, `npx --yes lazyclaude-ai@0.1.9 install`
 can resolve the local package and fail with `sh: lazyclaude-ai: command not
 found`. Use `cd /tmp` for the fresh directory scenario, or use the explicit
 fresh-prefix form:

package/bin/lazyclaude-ai.js

@@ -51,6 +51,13 @@ const intendedPluginPath = (home = claudeHome()) => claudePluginRoot(home);
 const marketplaceRoot = (home = lazyHome()) => join(home, "marketplaces", marketplaceName);
 const marketplacePluginPath = (home = lazyHome()) => join(marketplaceRoot(home), "plugins", "lazyclaude");
 const sourcePluginPath = () => join(root, "plugins", "lazyclaude");
+const lazyClaudeSettingsKey = "lazyclaude";
+const knownExternalLspPlugins = {
+  "typescript-lsp@claude-plugins-official": ["typescript-language-server"],
+  "rust-analyzer-lsp@claude-plugins-official": ["rust-analyzer"],
+  "pyright-lsp@claude-plugins-official": ["pyright-langserver", "pyright"],
+  "gopls-lsp@claude-plugins-official": ["gopls"],
+};
 
 const printUsage = () => {
   process.stderr.write(usage);
@@ -92,6 +99,8 @@ const writeClaudeSettings = (settings, home = claudeHome()) => {
   writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
 };
 
+const hudCommandForPlugin = (pluginPath) => `node "${join(pluginPath, "bin", "lazyclaude-hud.js")}"`;
+
 const readKnownMarketplaces = (home = claudeHome()) => {
   const path = knownMarketplacesPath(home);
   if (!existsSync(path)) return {};
@@ -166,6 +175,70 @@ const registerMarketplace = (marketplacePath, home = claudeHome()) => {
   writeKnownMarketplaces(knownMarketplaces, home);
 };
 
+const installHudStatusLine = (pluginPath, home = claudeHome()) => {
+  const settings = readClaudeSettings(home);
+  const command = hudCommandForPlugin(pluginPath);
+  const existingLazyClaude = settings[lazyClaudeSettingsKey] ?? {};
+  const now = new Date().toISOString();
+  const previousStatusLine =
+    existingLazyClaude.statusLineManaged === true
+      ? existingLazyClaude.previousStatusLine
+      : settings.statusLine;
+
+  settings.statusLine = {
+    type: "command",
+    command,
+  };
+  settings[lazyClaudeSettingsKey] = {
+    ...existingLazyClaude,
+    statusLineManaged: true,
+    statusLineCommand: command,
+    statusLineVersion: version,
+    statusLineInstalledAt: existingLazyClaude.statusLineInstalledAt ?? now,
+    statusLineUpdatedAt: now,
+    previousStatusLine: previousStatusLine ?? null,
+  };
+  writeClaudeSettings(settings, home);
+};
+
+const uninstallHudStatusLine = (home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  if (!existsSync(settingsPath)) return;
+
+  const settings = readClaudeSettings(home);
+  const lazyClaude = settings[lazyClaudeSettingsKey];
+  if (lazyClaude?.statusLineManaged !== true) return;
+
+  if (settings.statusLine?.command === lazyClaude.statusLineCommand) {
+    if (lazyClaude.previousStatusLine) {
+      settings.statusLine = lazyClaude.previousStatusLine;
+    } else {
+      delete settings.statusLine;
+    }
+  } else if (settings.statusLine?.command) {
+    process.stdout.write("HUD_WARNING: statusLine changed by user; leaving it untouched\n");
+  }
+
+  const remainingLazyClaude = { ...lazyClaude };
+  for (const key of [
+    "statusLineManaged",
+    "statusLineCommand",
+    "statusLineVersion",
+    "statusLineInstalledAt",
+    "statusLineUpdatedAt",
+    "previousStatusLine",
+  ]) {
+    delete remainingLazyClaude[key];
+  }
+
+  if (Object.keys(remainingLazyClaude).length > 0) {
+    settings[lazyClaudeSettingsKey] = remainingLazyClaude;
+  } else {
+    delete settings[lazyClaudeSettingsKey];
+  }
+  writeClaudeSettings(settings, home);
+};
+
 const unregisterMarketplace = (home = claudeHome()) => {
   const settingsPath = claudeSettingsPath(home);
   if (existsSync(settingsPath)) {
@@ -200,6 +273,7 @@ const registerClaudePlugin = (installRoot, marketplacePath, home = claudeHome())
   ];
   writeInstalledPlugins(registry, home);
   registerMarketplace(marketplacePath, home);
+  installHudStatusLine(installRoot, home);
 };
 
 const unregisterClaudePlugin = (home = claudeHome()) => {
@@ -221,6 +295,40 @@ const requireInstalledPluginPath = (home = claudeHome()) => {
   return path;
 };
 
+const commandExists = (command) => {
+  const result = spawnSync(command, ["--version"], {
+    encoding: "utf8",
+    stdio: "ignore",
+  });
+  return !result.error;
+};
+
+const printLspDiagnostics = (pluginPath, registry) => {
+  const lspPath = join(pluginPath, ".lsp.json");
+  const config = JSON.parse(readFileSync(lspPath, "utf8"));
+  const lazyClaudeServers = Object.keys(config);
+  process.stdout.write(`LAZYCLAUDE_LSP_SERVERS: ${lazyClaudeServers.join(", ") || "none"}\n`);
+
+  for (const server of lazyClaudeServers) {
+    const command = config[server]?.command?.[0];
+    if (command && !commandExists(command)) {
+      process.stdout.write(`LAZYCLAUDE_LSP_WARNING: ${server} requires ${command}; install it or remove that server from .lsp.json\n`);
+    }
+  }
+
+  const externalWarnings = [];
+  for (const [key, commands] of Object.entries(knownExternalLspPlugins)) {
+    if (!registry.plugins[key]?.length) continue;
+    if (commands.some(commandExists)) continue;
+    externalWarnings.push({ key, command: commands[0] });
+    process.stdout.write(`EXTERNAL_LSP_WARNING: ${key} requires ${commands[0]}\n`);
+  }
+
+  if (externalWarnings.length > 0) {
+    process.stdout.write("These warnings are not emitted by LazyClaude's .lsp.json; they come from other installed Claude Code LSP plugins.\n");
+  }
+};
+
 const resetCurrentPointer = (home, target) => {
   const current = currentRoot(home);
   rmSync(current, { recursive: true, force: true });
@@ -244,6 +352,7 @@ const install = ({ dryRun }) => {
     process.stdout.write(`Would copy: ${sourcePlugin} -> ${targetPlugin}\n`);
     process.stdout.write(`Would create local marketplace: ${targetMarketplace}\n`);
     process.stdout.write(`Would register Claude plugin: ${pluginKey}\n`);
+    process.stdout.write(`Would set Claude statusLine HUD: ${hudCommandForPlugin(targetPlugin)}\n`);
     process.stdout.write("Launch with: claude\n");
     return;
   }
@@ -268,6 +377,7 @@ const install = ({ dryRun }) => {
   process.stdout.write(`Claude plugin: ${pluginKey}\n`);
   process.stdout.write(`Marketplace: ${localMarketplace}\n`);
   process.stdout.write(`Plugin path: ${intendedPluginPath(home)}\n`);
+  process.stdout.write("HUD: LazyClaude statusLine installed\n");
   process.stdout.write("Launch with: claude\n");
 };
 
@@ -278,11 +388,13 @@ const doctor = ({ dryRun }) => {
     process.stdout.write(`Would check plugin files under: ${pluginPath}\n`);
     process.stdout.write(`Would run: claude plugin validate ${pluginPath}\n`);
     process.stdout.write(`Would check Claude plugin registry: ${pluginKey}\n`);
+    process.stdout.write(`Would check Claude statusLine HUD: ${hudCommandForPlugin(pluginPath)}\n`);
     return;
   }
 
   const pluginPath = requireInstalledPluginPath();
-  const registryEntry = readInstalledPlugins().plugins[pluginKey]?.[0];
+  const registry = readInstalledPlugins();
+  const registryEntry = registry.plugins[pluginKey]?.[0];
   if (!registryEntry) fail(`LazyClaude is missing from Claude plugin registry: ${pluginKey}`);
   const requiredFiles = [
     ".claude-plugin/plugin.json",
@@ -300,6 +412,8 @@ const doctor = ({ dryRun }) => {
     if (!existsSync(path)) fail(`LazyClaude install is missing ${file}. Run \`lazyclaude install\` again.`);
   }
 
+  printLspDiagnostics(pluginPath, registry);
+
   const claude = spawnSync("claude", ["--version"], { encoding: "utf8" });
   if (claude.error) {
     process.stdout.write("CLAUDE_WARNING: claude executable not found in PATH\n");
@@ -322,6 +436,12 @@ const doctor = ({ dryRun }) => {
   }
 
   process.stdout.write(`Plugin path: ${pluginPath}\n`);
+  const settings = readClaudeSettings();
+  if (settings.statusLine?.command === hudCommandForPlugin(pluginPath)) {
+    process.stdout.write("HUD_STATUSLINE_PASS\n");
+  } else {
+    process.stdout.write("HUD_STATUSLINE_WARNING: LazyClaude HUD is not the active Claude statusLine\n");
+  }
   process.stdout.write("Launch with: claude\n");
   process.stdout.write("DOCTOR_PASS\n");
 };
@@ -359,6 +479,7 @@ const uninstall = ({ dryRun }) => {
   rmSync(marketplaceRoot(home), { recursive: true, force: true });
   unregisterClaudePlugin();
   unregisterMarketplace();
+  uninstallHudStatusLine();
   rmSync(pluginCacheRoot, { recursive: true, force: true });
   process.stdout.write("UNINSTALL_PASS\n");
 };

package/docs/lsp.md

@@ -25,6 +25,11 @@ If `typescript-language-server` is unavailable, the doctor exits successfully
 with installation guidance so local smoke tests can distinguish an environment
 gap from a plugin failure.
 
+`lazyclaude doctor` also prints the LazyClaude LSP server names from the
+installed `.lsp.json`. If Claude Code reports load errors for official LSP
+plugins such as `rust-analyzer-lsp`, `pyright-lsp`, or `gopls-lsp`, LazyClaude
+reports those as external binary warnings rather than LazyClaude plugin errors.
+
 ## Claude Code Reload
 
 After changing `.lsp.json`, restart Claude Code with the local plugin directory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaude-ai",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Claude Code-native LazyCodex-style workflow distribution.",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
     "test": "node --test test/*.test.mjs",
     "validate:plugin": "node scripts/validate-plugin.mjs",
     "doctor": "node scripts/doctor.mjs",

package/plugins/lazyclaude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "lazyclaude",
   "description": "Claude Code-native LazyCodex-style workflow plugin.",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "author": {
     "name": "LazyClaude contributors"
   },

package/plugins/lazyclaude/bin/lazyclaude-hud.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const pluginManifestPath = join(pluginRoot, ".claude-plugin", "plugin.json");
+const noColor = process.env.NO_COLOR || process.env.LAZYCLAUDE_HUD_NO_COLOR === "1";
+const sep = process.env.LAZYCLAUDE_HUD_SEP || "│";
+
+const colors = noColor
+  ? { reset: "", bold: "", dim: "", accent: "", empty: "", green: "", yellow: "", red: "" }
+  : {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[38;5;245m",
+      accent: "\x1b[38;5;81m",
+      empty: "\x1b[38;5;238m",
+      green: "\x1b[38;5;71m",
+      yellow: "\x1b[38;5;178m",
+      red: "\x1b[38;5;167m",
+    };
+
+const readStdin = async () => {
+  let input = "";
+  for await (const chunk of process.stdin) input += chunk;
+  return input;
+};
+
+const readVersion = () => {
+  if (process.env.LAZYCLAUDE_VERSION) return process.env.LAZYCLAUDE_VERSION;
+  try {
+    return JSON.parse(readFileSync(pluginManifestPath, "utf8")).version ?? "?";
+  } catch {
+    return "?";
+  }
+};
+
+const shortModel = (raw) => {
+  const compact = String(raw || "?")
+    .replace(/\([^)]*\)/gu, "")
+    .replace(/\[[^\]]*\]/gu, "")
+    .replace(/\s+/gu, " ")
+    .trim();
+  const number = compact.match(/[0-9]+(?:\.[0-9]+)?/u)?.[0] ?? "";
+  if (/opus/iu.test(compact)) return `O${number}`;
+  if (/sonnet/iu.test(compact)) return `S${number}`;
+  if (/haiku/iu.test(compact)) return `H${number}`;
+  return compact.slice(0, 10) || "?";
+};
+
+const clamp = (value, min = 0, max = 100) => Math.max(min, Math.min(max, Number.isFinite(value) ? value : min));
+
+const barColor = (value) => {
+  if (value >= 90) return colors.red;
+  if (value >= 70) return colors.yellow;
+  return colors.green;
+};
+
+const makeBlockBar = (value, width = 5) => {
+  const pct = clamp(Math.round(value));
+  const filled = Math.floor((pct * width) / 100);
+  return `${barColor(pct)}${"█".repeat(filled)}${colors.empty}${"░".repeat(width - filled)}${colors.reset}`;
+};
+
+const makeContextBar = (value, width = 6) => {
+  const pct = clamp(Math.round(value));
+  const step = 100 / width;
+  let output = "";
+  for (let i = 0; i < width; i += 1) {
+    const progress = pct - i * step;
+    if (progress >= step * 0.8) output += `${colors.accent}█${colors.reset}`;
+    else if (progress >= step * 0.3) output += `${colors.accent}▄${colors.reset}`;
+    else output += `${colors.empty}░${colors.reset}`;
+  }
+  return output;
+};
+
+const latestUsageTokens = (transcriptPath) => {
+  if (!transcriptPath || !existsSync(transcriptPath)) return 0;
+  const lines = readFileSync(transcriptPath, "utf8").split(/\r?\n/u).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const event = JSON.parse(lines[index]);
+      const usage = event?.message?.usage;
+      if (!usage || event.isSidechain === true || event.isApiErrorMessage === true) continue;
+      return (
+        Number(usage.input_tokens ?? 0) +
+        Number(usage.cache_read_input_tokens ?? 0) +
+        Number(usage.cache_creation_input_tokens ?? 0)
+      );
+    } catch {
+    }
+  }
+  return 0;
+};
+
+const latestUserMessage = (transcriptPath) => {
+  if (!transcriptPath || !existsSync(transcriptPath)) return "";
+  const lines = readFileSync(transcriptPath, "utf8").split(/\r?\n/u).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const event = JSON.parse(lines[index]);
+      if (event.type !== "user") continue;
+      const content = event?.message?.content;
+      const text = Array.isArray(content)
+        ? content.filter((part) => part?.type === "text").map((part) => part.text).join(" ")
+        : content;
+      const normalized = String(text || "").replace(/\s+/gu, " ").trim();
+      if (normalized && !normalized.startsWith("[Request interrupted") && !normalized.startsWith("[Request cancelled")) {
+        return normalized;
+      }
+    } catch {
+    }
+  }
+  return "";
+};
+
+const gitStatus = (cwd) => {
+  if (!cwd || !existsSync(cwd)) return "";
+  try {
+    const branch = execFileSync("git", ["-C", cwd, "branch", "--show-current"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (!branch) return "";
+    const status = execFileSync("git", ["-C", cwd, "--no-optional-locks", "status", "--porcelain", "-uall"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const count = status ? status.split(/\r?\n/u).length : 0;
+    let sync = "✓";
+    try {
+      execFileSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "@{upstream}"], { stdio: "ignore" });
+      const [ahead, behind] = execFileSync("git", ["-C", cwd, "rev-list", "--left-right", "--count", "HEAD...@{upstream}"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim().split(/\s+/u).map(Number);
+      sync = `${ahead > 0 ? `↑${ahead}` : ""}${behind > 0 ? `↓${behind}` : ""}` || "✓";
+    } catch {
+      sync = "✓";
+    }
+    return `${branch}${count > 0 ? ` +${count}` : ""} ${sync}`;
+  } catch {
+    return "";
+  }
+};
+
+const parseUsage = () => {
+  const raw = process.env.LAZYCLAUDE_HUD_TEST_USAGE || process.env.CLAUDE_HUD_TEST_USAGE || "";
+  const values = {};
+  for (const part of raw.split(",")) {
+    const [key, value] = part.split("=");
+    if (!key || value === undefined) continue;
+    values[key.trim()] = value.trim();
+  }
+  return {
+    fiveHour: values["5h"] === undefined ? null : clamp(Number(values["5h"])),
+    weekly: values["1w"] === undefined && values.wk === undefined ? null : clamp(Number(values["1w"] ?? values.wk)),
+    weeklyReset: values.reset1 ?? values.resetw ?? "",
+  };
+};
+
+const formatReset = (iso) => {
+  if (!iso) return "";
+  const target = Date.parse(iso);
+  if (!Number.isFinite(target)) return "";
+  const minutes = Math.max(0, Math.floor((target - Date.now()) / 60000));
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `(${days}d${hours % 24}h)`;
+  if (hours > 0) return `(${hours}h${minutes % 60}m)`;
+  return `(${minutes}m)`;
+};
+
+const main = async () => {
+  const input = await readStdin();
+  const status = input.trim() ? JSON.parse(input) : {};
+  const version = readVersion();
+  const model = shortModel(status.model?.display_name ?? status.model?.id);
+  const maxContext = Number(status.context_window?.context_window_size ?? 200000);
+  const maxK = Math.max(1, Math.round(maxContext / 1000));
+  const tokens = latestUsageTokens(status.transcript_path);
+  const estimatedTokens = tokens > 0 ? tokens : 20000;
+  const contextPct = clamp(Math.floor((estimatedTokens * 100) / maxContext));
+  const usage = parseUsage();
+  const usageText =
+    usage.fiveHour === null || usage.weekly === null
+      ? ""
+      : ` ${sep} 5h [${makeBlockBar(usage.fiveHour)}]${barColor(usage.fiveHour)}${usage.fiveHour}%${colors.reset} ${sep} 1w [${makeBlockBar(usage.weekly)}]${barColor(usage.weekly)}${usage.weekly}%${colors.dim}${formatReset(usage.weeklyReset)}${colors.reset}`;
+  const git = gitStatus(status.cwd);
+  const prefix = `${colors.bold}${colors.accent}[LAZYCLAUDE v${version}]${colors.reset}`;
+  const line = `${prefix} | ${colors.accent}${model}${colors.dim} ${sep} ctx ${makeContextBar(contextPct)} ${contextPct}%/${maxK}k${colors.reset}${usageText}${git ? ` ${sep} git ${git}` : ""}`;
+  process.stdout.write(`${line}\n`);
+
+  const lastMessage = latestUserMessage(status.transcript_path);
+  if (lastMessage) {
+    const trimmed = lastMessage.length > 120 ? `${lastMessage.slice(0, 117)}...` : lastMessage;
+    process.stdout.write(`└─ ${trimmed}\n`);
+  }
+};
+
+main().catch((error) => {
+  process.stdout.write(`[LAZYCLAUDE v${readVersion()}] | HUD unavailable: ${error.message}\n`);
+  process.exit(0);
+});

package/scripts/postinstall.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+const skip = (reason) => {
+  process.stdout.write(`LazyClaude postinstall skipped: ${reason}\n`);
+  process.stdout.write("Run `lazyclaude install` to register the Claude Code plugin and HUD.\n");
+  process.exit(0);
+};
+
+if (process.env.LAZYCLAUDE_AUTO_INSTALL === "0" || process.env.LAZYCLAUDE_POSTINSTALL_SKIP === "1") {
+  skip("disabled by environment");
+}
+
+const forced = process.env.LAZYCLAUDE_AUTO_INSTALL === "1";
+if (process.env.CI && !forced) {
+  skip("CI environment");
+}
+
+if (existsSync(join(root, ".git")) && !forced) {
+  skip("source checkout");
+}
+
+if (process.env.npm_config_global !== "true" && process.env.npm_config_location !== "global" && !forced) {
+  skip("non-global package install");
+}
+
+const result = spawnSync(process.execPath, [join(root, "bin", "lazyclaude-ai.js"), "install"], {
+  cwd: root,
+  encoding: "utf8",
+  env: {
+    ...process.env,
+    LAZYCLAUDE_POSTINSTALL: "1",
+  },
+});
+
+if (result.status === 0) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  process.exit(0);
+}
+
+process.stdout.write("LazyClaude postinstall warning: automatic Claude Code plugin/HUD setup did not complete.\n");
+if (result.stderr) process.stdout.write(result.stderr);
+process.stdout.write("Run `lazyclaude install` manually after npm finishes.\n");
+process.exit(0);