litclaude-ai 0.2.2

package/plugins/litclaude/lib/hud-accent-palette.mjs

@@ -0,0 +1,58 @@
+export const HUD_ACCENT_THEMES = Object.freeze([
+  { name: "cyan", code: 81, mood: "LitClaude default" },
+  { name: "blue", code: 39, mood: "electric blue" },
+  { name: "teal", code: 49, mood: "bright teal" },
+  { name: "green", code: 118, mood: "neon green" },
+  { name: "lavender", code: 177, mood: "bright violet" },
+  { name: "rose", code: 198, mood: "hot pink" },
+  { name: "gold", code: 220, mood: "signal amber" },
+  { name: "orange", code: 208, mood: "vivid orange" },
+  { name: "slate", code: 75, mood: "ice blue" },
+  { name: "gray", code: 231, mood: "bright white" },
+]);
+
+const accentNames = new Set(HUD_ACCENT_THEMES.map((theme) => theme.name));
+
+export const normalizeHudAccent = (value) => {
+  const normalized = String(value || "").trim().toLowerCase();
+  return accentNames.has(normalized) ? normalized : "cyan";
+};
+
+export const themeForAccent = (value) => {
+  const normalized = normalizeHudAccent(value);
+  return HUD_ACCENT_THEMES.find((theme) => theme.name === normalized) ?? HUD_ACCENT_THEMES[0];
+};
+
+export const accentCodeForName = (value) => themeForAccent(value).code;
+
+// --- LitClaude neon brand banner (D21) -------------------------------------
+// `[🔥LITCLAUDE vX.Y.Z]` rendered as a neon glow. Truecolor terminals get a
+// per-letter hot-pink -> electric-cyan gradient; 256-color terminals fall back
+// to bright-magenta bold; NO_COLOR is plain text. The 🔥 is mandatory and the
+// brand is accent-independent (LITCLAUDE_HUD_ACCENT still themes the HUD body).
+const NEON_BRAND = "LITCLAUDE";
+const NEON_START = [255, 45, 149]; // #ff2d95 hot pink
+const NEON_END = [0, 229, 255]; // #00e5ff electric cyan
+
+export const supportsTruecolor = (env = process.env) =>
+  /truecolor|24bit/iu.test(String(env.COLORTERM || ""));
+
+export const litBrandPrefix = (version, { noColor = false, truecolor = false } = {}) => {
+  const label = `[🔥${NEON_BRAND} v${version}]`;
+  if (noColor) return label;
+  if (!truecolor) {
+    // 256-color neon fallback: bright magenta, bold.
+    return `\x1b[1m\x1b[38;5;201m${label}\x1b[0m`;
+  }
+  const n = NEON_BRAND.length;
+  let out = `\x1b[1m[🔥`;
+  for (let i = 0; i < n; i += 1) {
+    const t = n === 1 ? 0 : i / (n - 1);
+    const r = Math.round(NEON_START[0] + (NEON_END[0] - NEON_START[0]) * t);
+    const g = Math.round(NEON_START[1] + (NEON_END[1] - NEON_START[1]) * t);
+    const b = Math.round(NEON_START[2] + (NEON_END[2] - NEON_START[2]) * t);
+    out += `\x1b[38;2;${r};${g};${b}m${NEON_BRAND[i]}`;
+  }
+  out += `\x1b[38;2;${NEON_END[0]};${NEON_END[1]};${NEON_END[2]}m v${version}]\x1b[0m`;
+  return out;
+};

package/plugins/litclaude/lib/litgoal/cli.mjs

@@ -0,0 +1,266 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { appendLitgoalLedger } from "./ledger.mjs";
+import {
+  litgoalBriefPath,
+  litgoalGoalsPath,
+  litgoalLedgerPath,
+  litgoalLockDir,
+} from "./paths.mjs";
+import { readLitgoalState, LitgoalStateError, withLitgoalLock, writeLitgoalState } from "./state.mjs";
+
+const subcommands = [
+  ["create-goals", "Create durable goal records from a brief."],
+  ["status", "Print the current litgoal status."],
+  ["criteria", "List or update success criteria."],
+  ["record-evidence", "Record evidence as JSON."],
+  ["checkpoint", "Write a continuation checkpoint."],
+  ["steer", "Record a steering decision."],
+  ["record-review-blockers", "Record review blockers."],
+];
+
+const helpText = `Usage: litclaude-ai litgoal <command> [...args]
+       litclaude-ai litgoal --help
+
+Commands:
+${subcommands.map(([name, description]) => `  ${name.padEnd(22)} ${description}`).join("\n")}
+`;
+
+class LitgoalCliError extends Error {
+  constructor(message, status = 64) {
+    super(message);
+    this.name = "LitgoalCliError";
+    this.status = status;
+  }
+}
+
+const nowIso = () => new Date().toISOString();
+
+const hasFlag = (args, flag) => args.includes(flag);
+
+const optionValue = (args, flag) => {
+  const index = args.indexOf(flag);
+  if (index === -1) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) return "";
+  return value;
+};
+
+const requireOption = (args, flag, label = flag.slice(2)) => {
+  const value = optionValue(args, flag);
+  if (!value) throw new LitgoalCliError(`missing ${label}`);
+  return value;
+};
+
+const parseEvidenceJson = (args) => {
+  const index = args.indexOf("--json");
+  if (index === -1) return {};
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new LitgoalCliError("invalid litgoal JSON");
+  }
+};
+
+const emit = (io, payload, outputJson) => {
+  if (outputJson) {
+    io.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+  io.stdout.write(`${payload.message ?? JSON.stringify(payload)}\n`);
+};
+
+const readState = (cwd) => readLitgoalState(litgoalGoalsPath(cwd), null);
+
+const requireState = (cwd) => {
+  const state = readState(cwd);
+  if (!state) throw new LitgoalStateError("litgoal state not found");
+  return state;
+};
+
+const appendLedger = (cwd, entry) => appendLitgoalLedger(litgoalLedgerPath(cwd), entry);
+
+const defaultCriterion = (brief) => ({
+  id: "criterion-1",
+  description: "Objective has observable verification evidence.",
+  expectedEvidence: `Evidence that "${brief}" is complete.`,
+  status: "pending",
+  evidence: [],
+});
+
+const createGoals = (cwd, args) => {
+  const brief = requireOption(args, "--brief", "brief").trim();
+  if (!brief) throw new LitgoalCliError("missing brief");
+  return withLitgoalLock(litgoalLockDir(cwd), () => {
+    const timestamp = nowIso();
+    const state = {
+      version: 1,
+      objective: brief,
+      status: "active",
+      criteria: [defaultCriterion(brief)],
+      blockers: [],
+      steering: [],
+      checkpoints: [],
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    };
+
+    mkdirSync(dirname(litgoalBriefPath(cwd)), { recursive: true });
+    writeFileSync(litgoalBriefPath(cwd), `${brief}\n`);
+    writeLitgoalState(litgoalGoalsPath(cwd), state);
+    appendLedger(cwd, {
+      event: "goal.created",
+      objective: brief,
+      status: state.status,
+      criteria: state.criteria.map(({ id, status }) => ({ id, status })),
+    });
+    return state;
+  });
+};
+
+const listCriteria = (cwd) => {
+  const state = requireState(cwd);
+  return { criteria: state.criteria ?? [] };
+};
+
+const updateCriterionWithEvidence = (cwd, args) => {
+  const evidence = parseEvidenceJson(args);
+  return withLitgoalLock(litgoalLockDir(cwd), () => {
+    const criterionId = requireOption(args, "--criterion", "criterion");
+    const status = optionValue(args, "--status") || "pass";
+    if (!["pass", "fail", "blocked"].includes(status)) {
+      throw new LitgoalCliError("invalid evidence status");
+    }
+    const state = requireState(cwd);
+    const criterion = state.criteria?.find(({ id }) => id === criterionId);
+    if (!criterion) throw new LitgoalStateError("unknown criterion");
+
+    const record = {
+      status,
+      ...evidence,
+      recordedAt: nowIso(),
+    };
+    criterion.status = status;
+    criterion.evidence = [...(criterion.evidence ?? []), record];
+    state.updatedAt = record.recordedAt;
+    writeLitgoalState(litgoalGoalsPath(cwd), state);
+    appendLedger(cwd, {
+      event: "evidence.recorded",
+      criterionId,
+      status,
+      evidence,
+    });
+    return { criterion };
+  });
+};
+
+const checkpoint = (cwd, args) =>
+  withLitgoalLock(litgoalLockDir(cwd), () => {
+    const state = requireState(cwd);
+    const status = optionValue(args, "--status") || "active";
+    if (!["active", "complete", "blocked"].includes(status)) {
+      throw new LitgoalCliError("invalid checkpoint status");
+    }
+    const criteria = state.criteria ?? [];
+    if (status === "complete" && !criteria.every((criterion) => criterion.status === "pass")) {
+      throw new LitgoalStateError("criteria must pass before completion");
+    }
+
+    const record = {
+      status,
+      note: optionValue(args, "--note") || "",
+      createdAt: nowIso(),
+    };
+    state.status = status;
+    state.checkpoints = [...(state.checkpoints ?? []), record];
+    state.updatedAt = record.createdAt;
+    writeLitgoalState(litgoalGoalsPath(cwd), state);
+    appendLedger(cwd, { event: "checkpoint.recorded", ...record });
+    return { status: state.status, checkpoint: record };
+  });
+
+const steer = (cwd, args) =>
+  withLitgoalLock(litgoalLockDir(cwd), () => {
+    const state = requireState(cwd);
+    const kind = requireOption(args, "--kind", "kind");
+    if (!["scope", "priority", "blocker", "quality", "handoff"].includes(kind)) {
+      throw new LitgoalCliError("invalid steering kind");
+    }
+    const record = {
+      kind,
+      note: requireOption(args, "--note", "note"),
+      createdAt: nowIso(),
+    };
+    state.steering = [...(state.steering ?? []), record];
+    state.updatedAt = record.createdAt;
+    writeLitgoalState(litgoalGoalsPath(cwd), state);
+    appendLedger(cwd, { event: "steering.recorded", ...record });
+    return record;
+  });
+
+const recordReviewBlockers = (cwd, args) =>
+  withLitgoalLock(litgoalLockDir(cwd), () => {
+    const state = requireState(cwd);
+    const blocker = optionValue(args, "--blocker") || optionValue(args, "--note") || "review blocker recorded";
+    const record = {
+      blocker,
+      status: optionValue(args, "--status") || "blocked",
+      createdAt: nowIso(),
+    };
+    state.blockers = [...(state.blockers ?? []), record];
+    state.updatedAt = record.createdAt;
+    writeLitgoalState(litgoalGoalsPath(cwd), state);
+    appendLedger(cwd, { event: "review_blocker.recorded", ...record });
+    return record;
+  });
+
+const runCommand = (cwd, command, args) => {
+  switch (command) {
+    case "create-goals":
+      return createGoals(cwd, args);
+    case "status":
+      return requireState(cwd);
+    case "criteria":
+      return listCriteria(cwd);
+    case "record-evidence":
+      return updateCriterionWithEvidence(cwd, args);
+    case "checkpoint":
+      return checkpoint(cwd, args);
+    case "steer":
+      return steer(cwd, args);
+    case "record-review-blockers":
+      return recordReviewBlockers(cwd, args);
+    default:
+      throw new LitgoalCliError(`Unknown litgoal command: ${command}`);
+  }
+};
+
+export const runLitgoalCli = (argv, io = { stdout: process.stdout, stderr: process.stderr }, cwd = process.cwd()) => {
+  const [command, ...rest] = argv;
+
+  if (!command || command === "--help" || command === "-h") {
+    io.stdout.write(helpText);
+    return 0;
+  }
+
+  if (!subcommands.some(([name]) => name === command)) {
+    io.stderr.write(`Unknown litgoal command: ${command}\n`);
+    return 64;
+  }
+
+  try {
+    const outputJson = hasFlag(rest, "--json");
+    const result = runCommand(cwd, command, rest);
+    emit(io, result, outputJson);
+    return 0;
+  } catch (error) {
+    if (error instanceof LitgoalCliError || error instanceof LitgoalStateError) {
+      io.stderr.write(`${error.message}\n`);
+      return error.status;
+    }
+    io.stderr.write("litgoal runtime error\n");
+    return 1;
+  }
+};

package/plugins/litclaude/lib/litgoal/ledger.mjs

@@ -0,0 +1,16 @@
+import { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync } from "node:fs";
+import { dirname } from "node:path";
+
+export const appendLitgoalLedger = (path, entry) => {
+  mkdirSync(dirname(path), { recursive: true });
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  appendFileSync(path, `${JSON.stringify(record)}\n`);
+  // Flush the appended record to disk for durability.
+  const fd = openSync(path, "r");
+  fsyncSync(fd);
+  closeSync(fd);
+  return record;
+};

package/plugins/litclaude/lib/litgoal/paths.mjs

@@ -0,0 +1,7 @@
+import { join, resolve } from "node:path";
+
+export const litgoalStateDir = (cwd = process.cwd()) => join(resolve(cwd), ".litclaude", "litgoal");
+export const litgoalBriefPath = (cwd = process.cwd()) => join(litgoalStateDir(cwd), "brief.md");
+export const litgoalGoalsPath = (cwd = process.cwd()) => join(litgoalStateDir(cwd), "goals.json");
+export const litgoalLedgerPath = (cwd = process.cwd()) => join(litgoalStateDir(cwd), "ledger.jsonl");
+export const litgoalLockDir = (cwd = process.cwd()) => join(litgoalStateDir(cwd), ".lock");

package/plugins/litclaude/lib/litgoal/state.mjs

@@ -0,0 +1,67 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export class LitgoalStateError extends Error {
+  constructor(message, status = 65) {
+    super(message);
+    this.name = "LitgoalStateError";
+    this.status = status;
+  }
+}
+
+export const readLitgoalState = (path, fallback = {}) => {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new LitgoalStateError("corrupt litgoal state");
+  }
+};
+
+export const writeLitgoalState = (path, state) => {
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(state, null, 2)}\n`);
+  // Flush tmp file data to disk before rename so the rename is durable.
+  const fd = openSync(tmpPath, "r");
+  fsyncSync(fd);
+  closeSync(fd);
+  renameSync(tmpPath, path);
+  // Best-effort: fsync the parent directory so the directory entry is durable.
+  // Some filesystems (NTFS, FAT, certain network mounts) reject dir fsync with
+  // EINVAL/EPERM/EISDIR — swallow those silently.
+  try {
+    const dfd = openSync(dir, "r");
+    fsyncSync(dfd);
+    closeSync(dfd);
+  } catch {
+    // best-effort only; file data is already durable via the tmp fsync above
+  }
+};
+
+const sleepSync = (milliseconds) => {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+};
+
+export const withLitgoalLock = (lockDir, fn) => {
+  mkdirSync(dirname(lockDir), { recursive: true });
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      mkdirSync(lockDir, { recursive: false });
+      break;
+    } catch (error) {
+      if (Date.now() - startedAt > 5000) {
+        throw new LitgoalStateError("litgoal state lock timed out");
+      }
+      sleepSync(20);
+    }
+  }
+
+  try {
+    return fn();
+  } finally {
+    rmSync(lockDir, { recursive: true, force: true });
+  }
+};

package/plugins/litclaude/lib/mutated-file-paths.mjs

@@ -0,0 +1,63 @@
+const mutationToolNames = new Set(["apply_patch", "write", "edit", "multiedit", "multi_edit", "notebookedit"]);
+
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const addString = (paths, value) => {
+  if (typeof value === "string" && value.length > 0) paths.add(value);
+};
+
+const addStringArray = (paths, value) => {
+  if (!Array.isArray(value)) return;
+  for (const item of value) addString(paths, item);
+};
+
+const patchHeaderPath = (line) => {
+  for (const prefix of ["*** Add File: ", "*** Update File: ", "*** Move to: "]) {
+    if (line.startsWith(prefix)) return line.slice(prefix.length).trim();
+  }
+  return undefined;
+};
+
+const addPatchInput = (paths, value) => {
+  if (typeof value !== "string") return;
+  for (const line of value.split(/\r?\n/u)) {
+    const path = patchHeaderPath(line);
+    if (path) paths.add(path);
+  }
+};
+
+const addPatchRecords = (paths, value) => {
+  if (!Array.isArray(value)) return;
+  for (const item of value) {
+    if (!isRecord(item)) continue;
+    addString(paths, item.path);
+    addString(paths, item.filePath);
+    addString(paths, item.file_path);
+    addString(paths, item.movePath);
+    addString(paths, item.move_path);
+  }
+};
+
+const isFailedResponse = (value) =>
+  isRecord(value) && (value.isError === true || value.is_error === true || value.error === true || value.status === "error");
+
+export const extractMutatedFilePaths = (input) => {
+  const toolName = typeof input?.tool_name === "string" ? input.tool_name.toLowerCase() : "";
+  if (!mutationToolNames.has(toolName)) return [];
+  if (isFailedResponse(input.tool_response)) return [];
+
+  const toolInput = isRecord(input.tool_input) ? input.tool_input : {};
+  const paths = new Set();
+  addString(paths, toolInput.path);
+  addString(paths, toolInput.filePath);
+  addString(paths, toolInput.file_path);
+  addStringArray(paths, toolInput.paths);
+  addStringArray(paths, toolInput.filePaths);
+  addStringArray(paths, toolInput.file_paths);
+  addPatchInput(paths, toolInput.input);
+  addPatchInput(paths, toolInput.patch);
+  addPatchInput(paths, toolInput.command);
+  addPatchRecords(paths, toolInput.files);
+  addPatchRecords(paths, toolInput.changes);
+  return [...paths];
+};

package/plugins/litclaude/lib/start-work-continuation.mjs

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+
+const readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+
+const normalizeSessionId = (sessionId) => {
+  if (typeof sessionId !== "string" || sessionId.length === 0) return undefined;
+  return sessionId;
+};
+
+const activeWork = (state, sessionId) => {
+  if (!state || typeof state !== "object" || !state.works || typeof state.works !== "object") return null;
+  const active = typeof state.active_work_id === "string" ? state.works[state.active_work_id] : undefined;
+  if (active?.status === "active") return active;
+
+  const normalizedSession = normalizeSessionId(sessionId);
+  if (!normalizedSession) return null;
+  return Object.values(state.works).find((work) =>
+    work?.status === "active" && Array.isArray(work.session_ids) && work.session_ids.includes(normalizedSession),
+  ) ?? null;
+};
+
+const firstUncheckedTopLevelTask = (text) => {
+  for (const line of text.split(/\r?\n/u)) {
+    const match = /^- \[ \]\s+(.+?)\s*$/u.exec(line);
+    if (match) return match[1];
+  }
+  return null;
+};
+
+const planTitle = (text) => {
+  const match = /^#\s+(.+?)\s*$/mu.exec(text);
+  return match?.[1] ?? "";
+};
+
+const sanitizePath = (path) => path.replaceAll("\\", "/");
+
+const renderDirective = ({ planPath, ledgerPath, nextTask, worktreePath, planName, title }) => {
+  const lines = [
+    "LitClaude start-work continuation is active.",
+    `Plan: ${sanitizePath(planPath)}`,
+    `Ledger: ${sanitizePath(ledgerPath)}`,
+    `Next top-level task: ${nextTask}`,
+    "Before edits: reread the plan, ledger, Boulder state, and git status; continue with PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW -> CLEAN -> RECORD.",
+  ];
+  if (worktreePath) lines.splice(3, 0, `Worktree: ${sanitizePath(worktreePath)}`);
+  if (title) lines.splice(2, 0, `Title: ${title}`);
+  if (planName) lines.splice(1, 0, `Work: ${planName}`);
+  return lines.join("\n");
+};
+
+export const createStartWorkContinuation = (root, options = {}) => {
+  const boulderPath = join(root, ".litclaude", "boulder.json");
+  if (!existsSync(boulderPath)) return null;
+
+  let state;
+  try {
+    state = readJson(boulderPath);
+  } catch {
+    return null;
+  }
+
+  const work = activeWork(state, options.sessionId);
+  if (!work || typeof work.active_plan !== "string") return null;
+
+  const planPath = resolve(root, work.active_plan);
+  if (!existsSync(planPath)) return null;
+  const planText = readFileSync(planPath, "utf8");
+  const nextTask = firstUncheckedTopLevelTask(planText);
+  if (!nextTask) return null;
+
+  const ledgerPath = join(root, ".litclaude", "start-work", "ledger.jsonl");
+  return renderDirective({
+    planPath: work.active_plan,
+    ledgerPath: existsSync(ledgerPath) ? ".litclaude/start-work/ledger.jsonl" : ".litclaude/start-work/ledger.jsonl",
+    nextTask,
+    worktreePath: typeof work.worktree_path === "string" ? work.worktree_path : "",
+    planName: typeof work.plan_name === "string" ? work.plan_name : basename(planPath),
+    title: planTitle(planText),
+  });
+};
+
+export const runStartWorkContinuationCli = (defaultRoot, args, io = { stdout: process.stdout, stderr: process.stderr }) => {
+  const outputJson = args.includes("--json");
+  const rootIndex = args.indexOf("--root");
+  const sessionIndex = args.indexOf("--session-id");
+  const root = rootIndex >= 0 && typeof args[rootIndex + 1] === "string" ? resolve(args[rootIndex + 1]) : defaultRoot;
+  const sessionId = sessionIndex >= 0 ? args[sessionIndex + 1] : undefined;
+  const directive = createStartWorkContinuation(root, { sessionId });
+
+  if (outputJson) {
+    io.stdout.write(`${JSON.stringify({ status: directive ? "active" : "idle", directive }, null, 2)}\n`);
+  } else if (directive) {
+    io.stdout.write(`${directive}\n`);
+  } else {
+    io.stdout.write("START_WORK_CONTINUATION_IDLE\n");
+  }
+  return 0;
+};

package/plugins/litclaude/lib/workflow-check.mjs

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+
+const includesAll = (text, terms) => terms.every((term) => text.includes(term));
+
+const readText = (path) => readFileSync(path, "utf8");
+
+const runHookProbe = (root) => {
+  const hookPath = join(root, "plugins", "litclaude", "bin", "litclaude-hook.js");
+  const result = spawnSync(process.execPath, [hookPath, "user-prompt-submit"], {
+    cwd: root,
+    encoding: "utf8",
+    input: JSON.stringify({
+      hook_event_name: "UserPromptSubmit",
+      prompt: "$dynamic-workflow verify delegation",
+      cwd: root,
+    }),
+  });
+  if (result.status !== 0) return "";
+  try {
+    return JSON.parse(result.stdout).hookSpecificOutput?.additionalContext ?? "";
+  } catch {
+    return "";
+  }
+};
+
+export const createWorkflowCheckReport = (root, version) => {
+  const commandPath = join(root, "plugins", "litclaude", "commands", "dynamic-workflow.md");
+  const agentsPath = join(root, "docs", "agents.md");
+  const skillsRoot = join(root, "plugins", "litclaude", "skills");
+  const hookContext = runHookProbe(root);
+  const commandText = existsSync(commandPath) ? readText(commandPath) : "";
+  const agentsText = existsSync(agentsPath) ? readText(agentsPath) : "";
+  const orchestrationSkillText = ["lit-loop", "lit-plan", "start-work", "review-work"]
+    .map((skillName) => {
+      const path = join(skillsRoot, skillName, "SKILL.md");
+      return existsSync(path) ? readText(path) : "";
+    })
+    .join("\n");
+  const reliabilityTerms = ["TASK:", "DELIVERABLE", "SCOPE", "VERIFY", "short wait", "missing deliverable", "BLOCKED:"];
+
+  const checks = {
+    goalGuidance: includesAll(`${hookContext}\n${commandText}`, ["get_goal", "create_goal", "update_goal", "/goal"]),
+    dynamicWorkflowGuidance: includesAll(`${hookContext}\n${commandText}`, ["Workflow", "EnterWorktree", "claude --worktree"]),
+    subagentDelegation: includesAll(`${hookContext}\n${commandText}\n${agentsText}`, [
+      "prometheus-planner",
+      "boulder-executor",
+      "oracle-verifier",
+      "qa-runner",
+    ]),
+    subagentReliability: includesAll(`${hookContext}\n${commandText}\n${orchestrationSkillText}`, reliabilityTerms),
+    commandHookAgreement: includesAll(hookContext, reliabilityTerms) && includesAll(commandText, reliabilityTerms),
+    dynamicWorkflowCommand: existsSync(commandPath),
+    hookRoute: hookContext.includes("/litclaude:dynamic-workflow"),
+  };
+
+  const missing = Object.entries(checks)
+    .filter(([, passed]) => !passed)
+    .map(([name]) => name);
+
+  return {
+    status: missing.length === 0 ? "pass" : "fail",
+    version,
+    checks,
+    missing,
+  };
+};
+
+export const runWorkflowCheckCli = (root, version, args, io = { stdout: process.stdout, stderr: process.stderr }) => {
+  const outputJson = args.includes("--json");
+  const report = createWorkflowCheckReport(root, version);
+  if (outputJson) {
+    io.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } else {
+    io.stdout.write(`WORKFLOW_CHECK_${report.status.toUpperCase()}\n`);
+    for (const [name, passed] of Object.entries(report.checks)) {
+      io.stdout.write(`${name}=${passed ? "pass" : "fail"}\n`);
+    }
+    if (report.missing.length) io.stdout.write(`missing=${report.missing.join(",")}\n`);
+  }
+  return report.status === "pass" ? 0 : 1;
+};