litclaude-ai 0.2.2

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

@@ -0,0 +1,271 @@
+#!/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";
+import { accentCodeForName, litBrandPrefix, supportsTruecolor } from "../lib/hud-accent-palette.mjs";
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const pluginManifestPath = join(pluginRoot, ".claude-plugin", "plugin.json");
+const noColor = process.env.NO_COLOR || process.env.LITCLAUDE_HUD_NO_COLOR === "1";
+const sep = process.env.LITCLAUDE_HUD_SEP || "│";
+const configuredAccent = String(process.env.LITCLAUDE_HUD_ACCENT || "cyan").toLowerCase();
+const accentCode = accentCodeForName(configuredAccent);
+
+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;${accentCode}m`,
+      empty: "\x1b[38;5;238m",
+      green: "\x1b[38;5;71m",
+      yellow: "\x1b[38;5;178m",
+      red: "\x1b[38;5;167m",
+    };
+
+const accent = (text) => `${colors.accent}${text}${colors.reset}`;
+
+const readStdin = async () => {
+  let input = "";
+  for await (const chunk of process.stdin) input += chunk;
+  return input;
+};
+
+const readVersion = () => {
+  if (process.env.LITCLAUDE_VERSION) return process.env.LITCLAUDE_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 displayPercent = (value) => Math.round(clamp(value));
+
+const barColor = (value) => {
+  if (value >= 90) return colors.red;
+  if (value >= 70) return colors.yellow;
+  return colors.green;
+};
+
+const makeBlockBar = (value, width = 3, color = null) => {
+  const pct = clamp(Math.round(value));
+  const exact = (pct * width) / 100;
+  const filled = Math.floor(exact);
+  const partial = exact - filled;
+  const partialBlocks = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
+  const partialIndex = filled < width && partial > 0 ? Math.max(1, Math.min(7, Math.round(partial * 8))) : 0;
+  const empty = width - filled - (partialIndex > 0 ? 1 : 0);
+  return `${color ?? barColor(pct)}${"█".repeat(filled)}${partialBlocks[partialIndex]}${colors.empty}${"░".repeat(empty)}${colors.reset}`;
+};
+
+const makeContextBar = (value, width = 3) => {
+  const pct = clamp(Math.round(value));
+  return makeBlockBar(pct, width, colors.accent);
+};
+
+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);
+  const ignoredPrefixes = ["[Request interrupted", "[Request cancelled", "<local-command-stdout>", "<local-command-stderr>"];
+  const hasCommandXml = (text) => /<(?:command-name|command-message|command-args)\b[^>]*>/u.test(text);
+  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 && !ignoredPrefixes.some((prefix) => normalized.startsWith(prefix)) && !hasCommandXml(normalized)) {
+        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 firstNumber = (...values) => {
+  for (const value of values) {
+    const number = Number(value);
+    if (Number.isFinite(number)) return number;
+  }
+  return null;
+};
+
+const firstString = (...values) => {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  }
+  return "";
+};
+
+const parseUsage = (status) => {
+  const raw = process.env.LITCLAUDE_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();
+  }
+  const fiveHour = status.rate_limits?.five_hour ?? status.rate_limits?.["5_hour"] ?? {};
+  const sevenDay = status.rate_limits?.seven_day ?? status.rate_limits?.["7_day"] ?? status.rate_limits?.weekly ?? {};
+  const fiveHourPct = firstNumber(values["5h"], values.five_hour, fiveHour.used_percentage, fiveHour.percentage, fiveHour.usedPercent);
+  const weeklyPct = firstNumber(values["1w"], values.wk, values.seven_day, sevenDay.used_percentage, sevenDay.percentage, sevenDay.usedPercent);
+  return {
+    fiveHour: fiveHourPct === null ? null : clamp(fiveHourPct),
+    fiveHourReset: firstString(
+      values.reset5,
+      values.reset5h,
+      fiveHour.resets_at,
+      fiveHour.reset_at,
+      fiveHour.reset_time,
+      fiveHour.resetAt,
+      fiveHour.resetTime,
+      fiveHour.next_reset,
+      fiveHour.nextReset,
+    ),
+    weekly: weeklyPct === null ? null : clamp(weeklyPct),
+    weeklyReset: firstString(
+      values.reset1,
+      values.resetw,
+      values.reset7,
+      values.reset7d,
+      sevenDay.resets_at,
+      sevenDay.reset_at,
+      sevenDay.reset_time,
+      sevenDay.resetAt,
+      sevenDay.resetTime,
+      sevenDay.next_reset,
+      sevenDay.nextReset,
+    ),
+  };
+};
+
+const parseResetTarget = (value) => {
+  if (!value) return NaN;
+  const raw = String(value).trim();
+  if (/^\d+(?:\.\d+)?$/u.test(raw)) {
+    const epoch = Number(raw);
+    return epoch < 100000000000 ? epoch * 1000 : epoch;
+  }
+  return Date.parse(raw);
+};
+
+const formatReset = (value) => {
+  const target = parseResetTarget(value);
+  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 formatUsageSegment = (label, value, reset) => {
+  const labelText = accent(label);
+  if (value === null) return `${labelText} ${accent("[")}${colors.accent}░░${colors.reset}${accent("]")} ${accent("--%")}`;
+  const pct = displayPercent(value);
+  const resetText = formatReset(reset);
+  return `${labelText} ${accent("[")}${makeBlockBar(pct, 2)}${accent("]")} ${barColor(pct)}${pct}%${colors.reset}${resetText ? ` ${accent(resetText)}` : ""}`;
+};
+
+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 statusContextPct = firstNumber(status.context_window?.used_percentage, status.context_window?.usage_percentage);
+  const rawContextPct = statusContextPct === null ? Math.floor((estimatedTokens * 100) / maxContext) : statusContextPct;
+  const contextPct = displayPercent(rawContextPct);
+  const usage = parseUsage(status);
+  const usageText = ` ${accent(sep)} ${formatUsageSegment("5h", usage.fiveHour, usage.fiveHourReset)} ${accent(sep)} ${formatUsageSegment("1w", usage.weekly, usage.weeklyReset)}`;
+  const git = gitStatus(status.cwd);
+  const prefix = litBrandPrefix(version, { noColor, truecolor: supportsTruecolor() });
+  const contextText = `${accent("ctx")} ${accent("[")}${makeContextBar(contextPct)}${accent("]")} ${accent(`${contextPct}%/${maxK}k`)}`;
+  const line = `${prefix} ${accent("|")} ${accent(model)} ${accent(sep)} ${contextText}${usageText}${git ? ` ${accent(sep)} ${accent("git")} ${accent(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(`[🔥LITCLAUDE v${readVersion()}] | HUD unavailable: ${error.message}\n`);
+  process.exit(0);
+});

package/plugins/litclaude/bin/litclaude-lsp-doctor.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+
+const result = spawnSync("typescript-language-server", ["--version"], {
+  encoding: "utf8",
+});
+
+if (result.error) {
+  console.log("typescript-language-server is not available.");
+  console.log("Install with: npm install -g typescript-language-server typescript");
+  process.exit(0);
+}
+
+console.log(`typescript-language-server available: ${(result.stdout || result.stderr).trim()}`);

package/plugins/litclaude/bin/litclaude-mcp.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const protocolVersion = "2024-11-05";
+
+const write = (message) => {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+};
+
+const result = (id, value) => write({ jsonrpc: "2.0", id, result: value });
+
+const error = (id, code, message) => write({ jsonrpc: "2.0", id, error: { code, message } });
+
+const handleMessage = (message) => {
+  if (!message || typeof message !== "object" || !("id" in message)) {
+    return;
+  }
+
+  switch (message.method) {
+    case "initialize":
+      result(message.id, {
+        protocolVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: "litclaude", version: "0.1.0" },
+      });
+      break;
+    case "ping":
+      result(message.id, {});
+      break;
+    case "tools/list":
+      result(message.id, { tools: [] });
+      break;
+    case "tools/call":
+      error(message.id, -32601, "LitClaude MCP exposes no callable tools in this MVP.");
+      break;
+    default:
+      error(message.id, -32601, `Unknown method: ${message.method}`);
+      break;
+  }
+};
+
+let buffer = "";
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  buffer += chunk;
+  let newlineIndex = buffer.indexOf("\n");
+  while (newlineIndex !== -1) {
+    const line = buffer.slice(0, newlineIndex).trim();
+    buffer = buffer.slice(newlineIndex + 1);
+    if (line) {
+      try {
+        handleMessage(JSON.parse(line));
+      } catch {
+        error(null, -32700, "Parse error");
+      }
+    }
+    newlineIndex = buffer.indexOf("\n");
+  }
+});
+
+process.stdin.on("end", () => {
+  const line = buffer.trim();
+  if (line) {
+    try {
+      handleMessage(JSON.parse(line));
+    } catch {
+      error(null, -32700, "Parse error");
+    }
+  }
+});

package/plugins/litclaude/commands/deep-interview.md

@@ -0,0 +1,21 @@
+---
+description: Clarify broad or underspecified work before planning or implementation.
+argument-hint: '[--quick|--standard|--deep] <idea or vague description>'
+---
+
+Use the `deep-interview` skill for the user's current brief or command
+arguments.
+
+Run it as a requirements mode, not an implementation mode:
+
+- Ask one question per round.
+- Gather read-only codebase facts before asking the user for facts Claude can
+  discover directly.
+- Track ambiguity, non-goals, decision boundaries, and a pressure pass.
+- Persist state under `deep-interview/` so interrupted interviews can resume.
+- Crystallize a spec before handing off to `/litclaude:lit-plan`,
+  `/litclaude:lit-loop`, or `/litclaude:start-work`.
+
+If the user has already supplied concrete files, acceptance criteria, and
+non-goals, state that the interview can be skipped and hand the brief to the
+appropriate planning or execution command.

package/plugins/litclaude/commands/dynamic-workflow.md

@@ -0,0 +1,36 @@
+---
+description: Verify and run LitClaude Dynamic workflow delegation.
+argument-hint: '<objective>'
+---
+
+Use the `lit-loop` skill for the user's current objective, with this
+Dynamic-workflow bootstrap first.
+
+1. Inspect native goal state when model-facing tools are exposed: call
+   `get_goal`, call `create_goal` only when no matching active goal exists, and
+   reserve `update_goal` for verified completion or a genuine blocker. If only
+   the user-visible goal surface is available, ask for one exact
+   `/goal <completion condition>` instead of claiming LitClaude set it.
+2. Run `litclaude-ai workflow-check --json` when the package CLI is available.
+   Treat a failing check as BLOCKED until the missing route, command, or
+   subagent delegation surface is fixed.
+3. For broad, risky, parallel, or long-running work, call the `Workflow` tool
+   when Claude Code exposes it. Bind each lane to success criteria, evidence
+   artifacts, and cleanup receipts.
+4. Use subagent delegation where available:
+   - `prometheus-planner` for read-only planning and dependency ordering.
+   - `boulder-executor` for implementation against a checked plan.
+   - `oracle-verifier` for evidence and acceptance verification.
+   - `qa-runner` for tmux/manual-QA scenarios and cleanup receipts.
+   - `quality-reviewer` for code-quality and security findings.
+   - `librarian-researcher` for local-first context mining.
+   Each child assignment starts with `TASK:` and includes `DELIVERABLE`,
+   `SCOPE`, and `VERIFY`. Use short wait cycles; treat timeouts as no-update
+   signals, and fallback only after a missing deliverable, acknowledgement-only
+   reply, or `BLOCKED:` report.
+5. For isolated edit lanes, use `EnterWorktree` when exposed. If only the CLI
+   surface exists, use or recommend `claude --worktree <short-name> --tmux`.
+
+Do not auto-type `/goal`, do not echo or execute prompt text, and do not mutate
+remote state. Continue through the normal LitClaude evidence loop:
+`PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW -> CLEAN -> RECORD`.

package/plugins/litclaude/commands/lit-loop.md

@@ -0,0 +1,40 @@
+---
+description: Run LitClaude lit-loop discipline with goal and Dynamic workflow bootstrap.
+argument-hint: '<objective>'
+---
+
+Use the `lit-loop` skill for the user's current objective or command arguments.
+
+Before implementation, bootstrap Claude Code-native workflow state:
+
+1. If model-facing goal tools are available in this session, inspect `get_goal`,
+   call `create_goal` only when no matching goal exists, and reserve
+   `update_goal` for verified completion or a genuine blocker.
+2. If goal tools are unavailable, state that plainly and ask the user to bind
+   the native Claude Code goal with this exact surface before long execution:
+   `/goal <completion condition for the current objective>`.
+3. For broad, risky, parallel, or long-running work, call the `Workflow` tool
+   when Claude Code exposes it. Bind every lane to explicit criteria, evidence
+   artifacts, and cleanup receipts.
+4. When isolated edits are needed, use `EnterWorktree` when Claude Code exposes
+   it. If only the CLI surface is available, tell the user the concrete launch
+   form: `claude --worktree <short-name> --tmux`.
+
+Then continue with evidence-bound success criteria, tests, manual QA artifacts,
+cleanup receipts, and explicit release approval boundaries.
+
+Run the objective through `PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW
+-> CLEAN -> RECORD`:
+
+- PIN the objective, non-goals, stale state to reread, dirty worktree files,
+  commit/push approval, publish approval, and resume checkpoint.
+- RED before implementation when behavior changes, then GREEN with targeted
+  evidence and broader verification.
+- SURFACE with a real Manual-QA channel and artifact.
+- REVIEW when the change is broad, risky, shared, security-sensitive, or
+  release-facing.
+- CLEAN with a bounded cleanup receipt for tmux sessions, servers, ports,
+  browser contexts, temp directories, and child processes.
+
+Stop rules: stop before unapproved commit/push or publish, stop on malformed or
+contradictory requirements, and reread live repo state on resume before acting.

package/plugins/litclaude/commands/lit-plan.md

@@ -0,0 +1,35 @@
+---
+description: Plan LitClaude work with explicit goal, Dynamic workflow, and QA criteria.
+argument-hint: '<planning brief>'
+---
+
+Use the `lit-plan` skill for the user's current planning brief or command
+arguments.
+
+The plan must include Claude Code-native bootstrap steps:
+
+- If model-facing goal tools are exposed, use `get_goal`, `create_goal`, and
+  delayed `update_goal` exactly as native goal state, not as slash-command text.
+- If goal tools are unavailable, include the exact user-visible `/goal`
+  completion condition to bind before execution.
+- For independent, risky, parallel, or long-running work, include when Claude
+  should call the `Workflow` tool and how each lane proves its evidence.
+- For isolated edit lanes, include when to use `EnterWorktree`; if only the CLI
+  surface is available, include `claude --worktree <short-name> --tmux`, plus
+  evidence paths and cleanup.
+
+Write the plan under `plans/` and keep it executable: concrete files, tests,
+manual QA, cleanup, and publish/remote-mutation guardrails.
+
+The plan must include a strict execution section:
+
+- Bootstrap and PIN: objective, non-goals, stale state, dirty worktree
+  constraints, resume ledger, commit/push boundary, and publish boundary.
+- TDD loop: `PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW -> CLEAN ->
+  RECORD`.
+- Manual-QA: exact channel, command or steps, PASS/FAIL observable, artifact
+  path, and cleanup receipt.
+- Reviewer gate: when to run it and what artifact proves it passed or was not
+  required.
+- Stop rules: stop on malformed plan input, contradictory live state,
+  unapproved remote mutation, missing artifacts, or repeated identical failure.

package/plugins/litclaude/commands/litgoal.md

@@ -0,0 +1,30 @@
+---
+description: Manage LitClaude litgoal ledger and durable goal state.
+argument-hint: '<goal operation>'
+---
+
+Use the `litgoal` skill for the user's current goal operation or command
+arguments.
+
+Prefer the package CLI for durable local state:
+`litclaude-ai litgoal create-goals`, `status`, `criteria`,
+`record-evidence`, `checkpoint`, `steer`, and `record-review-blockers`.
+The installed alias may also be invoked as:
+
+```bash
+litclaude litgoal create-goals --brief "<brief>" --json
+litclaude litgoal record-evidence --criterion <id> --status pass --json '{"artifact":"...","cleanup":"..."}'
+litclaude litgoal checkpoint --status active --note "<progress>" --json
+litclaude litgoal steer --kind scope --note "<what changed and why>" --json
+```
+
+The ledger lives under `.litclaude/litgoal/` unless test environment variables
+override it. Bind work to native goal tools when they are available; when goal
+tools are unavailable, record clear criteria and evidence in the local ledger.
+For broad goal execution, use Dynamic workflow when Claude Code exposes it, and
+use `claude --worktree <short-name> --tmux` only when isolated worktree
+execution is needed.
+Manual-QA channels and cleanup receipt artifacts should be recorded with
+`record-evidence`. Malformed JSON, unknown criteria, corrupt state, and invalid
+steering kinds must fail as controlled errors. Use current docs/test reads
+before trusting stale local state.

package/plugins/litclaude/commands/review-work.md

@@ -0,0 +1,35 @@
+---
+description: Run LitClaude 5-lane review discipline.
+argument-hint: '<scope>'
+---
+
+Use the `review-work` skill for the user's current scope or command arguments.
+
+Run the 5-lane review contract: goal and constraint verification
+(goal/constraint), hands-on QA execution, code quality review, security review,
+and local-first context mining.
+Aggregate findings into a PASS, FAIL, or NEEDS-CONTEXT verdict, and cite the
+evidence used for every lane.
+Manual-QA channels must leave artifacts, cleanup receipt paths, and bounded
+session teardown proof. Respect the publish boundary: reviewing release
+readiness is allowed, but npm publish, remote marketplace registration, and
+other remote mutation still need explicit user approval.
+
+Lane routing:
+
+- goal and constraint verification: use `oracle-verifier` with `review-work`
+  and `rules`.
+- hands-on QA execution: use `qa-runner` with `start-work` and `review-work`.
+- code quality review: use `quality-reviewer` with `review-work` and
+  `programming`.
+- security review: use `quality-reviewer` with `review-work` and
+  `programming`.
+- local-first context mining: use `librarian-researcher` with `rules`.
+
+Before launching broad review work, check whether native goal tools are
+available and bind the review to the active goal. If goal tools are unavailable,
+keep the local evidence ledger authoritative. For large independent lanes, use
+Dynamic workflow when Claude Code exposes it, and use `claude --worktree` only
+when isolated review edits or reproduction steps need a separate checkout.
+Use current docs/test reads before trusting stale local state or continuation
+notes.

package/plugins/litclaude/commands/start-work.md

@@ -0,0 +1,36 @@
+---
+description: Execute a checked plan with LitClaude start-work discipline.
+argument-hint: '<plan-file>'
+---
+
+Use the `start-work` skill for the user's current plan file or command
+arguments.
+
+Before the first checkbox, bootstrap Claude Code-native workflow state:
+
+- Use `get_goal` and `create_goal` only if model-facing goal tools are exposed.
+- If goal tools are unavailable, ask the user to set a native `/goal` completion
+  condition for the plan before multi-turn execution.
+- For broad, risky, parallel, or long-running checkbox waves, call the
+  `Workflow` tool when Claude Code exposes it.
+- For isolated edit lanes, use `EnterWorktree` when exposed; otherwise launch
+  or recommend `claude --worktree <short-name> --tmux`.
+
+Then execute the first unchecked top-level checkbox with failing-test-first
+implementation, automated verification, manual QA evidence, cleanup receipts,
+and ledger updates.
+
+For that checkbox, enforce `PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW
+-> CLEAN -> RECORD`:
+
+- PIN the plan objective, selected checkbox, stale state, dirty worktree
+  boundaries, resume checkpoint, commit/push approval, and publish approval.
+- RED first for behavior changes, then GREEN with targeted and plan-level tests.
+- SURFACE through the plan's Manual-QA channel with an artifact path.
+- REVIEW broad, risky, shared, security-sensitive, or release-facing changes.
+- CLEAN with bounded cleanup receipt for tmux sessions, servers, ports, browser
+  contexts, temp directories, and child processes.
+
+Stop rules: stop on malformed plan structure, missing acceptance criteria,
+missing Manual-QA or cleanup requirements, contradictory live state, or
+unapproved commit/push or publish.

package/plugins/litclaude/hooks/hooks.json

@@ -0,0 +1,54 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/litclaude-hook.js\" session-start",
+            "timeout": 10,
+            "statusMessage": "loading LitClaude rules"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/litclaude-hook.js\" user-prompt-submit",
+            "timeout": 5,
+            "statusMessage": "checking LitClaude workflow trigger"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "^(Write|Edit|MultiEdit|NotebookEdit)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/litclaude-hook.js\" post-tool-use",
+            "timeout": 30,
+            "statusMessage": "running LitClaude post-edit checks"
+          }
+        ]
+      }
+    ],
+    "PostCompact": [
+      {
+        "matcher": "manual|auto",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/litclaude-hook.js\" post-compact",
+            "timeout": 10,
+            "statusMessage": "resetting LitClaude rule cache"
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/litclaude/lib/context-pressure.mjs

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+
+const contextPressureMarkers = [
+  "context compacted",
+  "context_length_exceeded",
+  "context_too_large",
+  "context window",
+  "skill descriptions were shortened",
+  "input exceeds the context",
+];
+
+export const hasContextPressure = (text) => {
+  if (typeof text !== "string") return false;
+  const normalized = text.toLowerCase();
+  return contextPressureMarkers.some((marker) => normalized.includes(marker));
+};
+
+export const transcriptHasContextPressure = (transcriptPath) => {
+  if (typeof transcriptPath !== "string" || transcriptPath.length === 0) return false;
+  try {
+    return hasContextPressure(readFileSync(transcriptPath, "utf8"));
+  } catch {
+    return false;
+  }
+};