litclaude-ai 0.2.2

package/plugins/litclaude/skills/start-work/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: start-work
+description: Execute a checked plan file with LitClaude Boulder state, top-level checkbox discipline, goal/workflow/worktree bootstrap, evidence ledgers, and cleanup receipts.
+---
+
+# Start Work
+
+Use this skill when the user asks to execute a plan file, especially
+`$start-work plans/<slug>.md`. The plan file and ledger are the source of truth,
+not memory.
+
+## Bootstrap
+
+Before the first edit:
+
+1. Read the requested plan file.
+2. Read `.litclaude/start-work/ledger.jsonl` when it exists.
+3. Inspect `.litclaude/boulder.json` when it exists.
+4. Pick the first unchecked top-level checkbox in `## TODOs` or final
+   verification sections. Ignore nested acceptance criteria as task selectors.
+5. Decompose that checkbox into atomic tasks with tests and QA artifacts.
+6. PIN the current objective, stale state to reread, dirty worktree boundaries,
+   commit/push approval, publish approval, resume checkpoint, and required
+   cleanup receipt paths before editing.
+
+## Native Goal + Dynamic Workflow
+
+Before the first checkbox, use Claude Code's native goal surface when available:
+
+- call `get_goal` if exposed
+- call `create_goal` with the plan objective only when no matching active goal
+  exists
+- call `update_goal` only after all top-level checkboxes and final gates are
+  complete, or when the plan is genuinely blocked
+- if the user invokes `/goal`, respect it as the native session goal
+- do not auto-type or send `/goal` text from a skill
+
+If model-facing goal tools are absent, continue with Boulder/ledger discipline.
+For long plans, ask once for `/goal <plan completion condition>` if that would
+help the user keep the session bounded.
+If goal tools are not exposed, do not print repeated fallback status; just keep
+the plan ledger accurate and continue with verified evidence.
+
+For broad, risky, or parallel checkbox waves, use Dynamic workflow orchestration
+and call `Workflow` when exposed. Use Dynamic worktree isolation with
+`EnterWorktree` for isolated model-facing edit lanes when available. When
+only the CLI path is available, use or recommend
+`claude --worktree <short-name> --tmux`.
+
+## Subagent Assignment Contract
+
+For each decomposed checkbox, child-agent assignments must be executable, not
+context-only. Start each assignment with `TASK:` and include `DELIVERABLE`,
+`SCOPE`, and `VERIFY`. Name exact files or directories, the characterization
+test or RED reproduction, implementation constraints, automated verification,
+Manual-QA channel, adversarial classes, artifact path, and cleanup receipt.
+
+Run independent assignments in the background only when file scopes do not
+collide. Use short wait cycles for mailbox updates; a timeout is not a failure
+or approval. If the child returns no deliverable, sends only acknowledgement,
+or reports `BLOCKED:`, record the missing deliverable and issue one targeted
+follow-up before using a smaller fallback assignment. Reviewer fallback must
+keep a reviewer role and is not a generic worker task.
+
+## Per-Checkbox Loop
+
+For the selected checkbox:
+
+1. Re-read the checkbox, acceptance criteria, and prior evidence.
+2. PIN the exact file scope, non-goals, and stale facts that must be refreshed.
+3. Write or update the test first; capture RED when behavior changes.
+4. Implement the smallest change and capture GREEN with the targeted test.
+5. Run broader verification requested by the plan.
+6. Run the plan's Manual-QA scenario and capture the SURFACE artifact.
+7. Run the reviewer gate when the checkbox is broad, risky, shared,
+   security-sensitive, or release-facing.
+8. Clean resources and capture cleanup receipt. Cleanup must be bounded with a
+   timeout or kill path for tmux sessions, servers, ports, browser contexts,
+   temp directories, and child processes.
+9. Mark the top-level checkbox complete only after evidence exists.
+10. Append a `task-completed` line to `.litclaude/start-work/ledger.jsonl`.
+
+Do not mark every checkbox at the end in a batch. Progress is durable and
+incremental.
+
+Use `PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW -> CLEAN -> RECORD` as
+the execution shorthand. If any step is missing, leave the checkbox open.
+
+## Evidence Standards
+
+Every completed checkbox needs:
+
+- automated test command and result
+- manual QA artifact path
+- cleanup receipt
+- reviewer result or a recorded reason the reviewer gate was not required
+- changed files or commit hash when applicable
+- any skipped adversarial classes with reason
+
+`--dry-run`, "looks right", or a worker's self-report is insufficient.
+
+## Failure Handling
+
+If a subtask fails, retry the same task with the exact error, diagnosis, and
+fix instruction. After repeated identical failures, stop and surface the
+blocker with artifacts. Do not start fresh and lose the failure context.
+
+On resume after cancel, compaction, terminal restart, or repeated interruption,
+reread the plan, ledger, `.litclaude/boulder.json`, and `git status --short` before
+acting. Treat prior green output as stale unless the artifact path still exists
+and includes the command plus STATUS line. Never revert dirty worktree changes
+you did not make.
+
+Use `litclaude-ai start-work-next --json` when you need a compact continuation
+directive from the current `.litclaude/boulder.json` state. It prints the active plan,
+ledger, worktree when known, and the next unchecked top-level checkbox without
+mutating state. If Claude Code later exposes a stable Stop/SubagentStop plugin
+hook schema for this package shape, wire the same helper there; until then the
+CLI helper is the supported continuation surface.
+
+## Finalization
+
+When all top-level checkboxes are complete, run the plan's final verification
+wave, update the plan file, update the ledger, commit/push if requested, and
+leave a handoff if the session stops at a checkpoint.
+
+## Stop rules
+
+Stop before commit/push or publish unless the user approved it for this run.
+Stop when the plan is malformed, missing acceptance criteria, missing Manual-QA
+channels, missing cleanup receipts, or contradicts current repository state.
+Record the blocker and the next executable command instead of guessing.

package/scripts/audit-plan-checkboxes.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+
+const planPath = process.argv[2];
+
+if (!planPath) {
+  process.stderr.write("usage: audit-plan-checkboxes.mjs <plan.md>\n");
+  process.exit(64);
+}
+
+const text = await readFile(planPath, "utf8");
+const taskPattern = /^- \[[ x]\] (?:\d+\.|F\d\.) .+$/gm;
+const tasks = [...text.matchAll(taskPattern)];
+
+assert.ok(tasks.some((task) => /^- \[[ x]\] \d+\./.test(task[0])), "expected implementation task checkboxes");
+assert.ok(tasks.some((task) => /^- \[[ x]\] F\d\./.test(task[0])), "expected final verification checkboxes");
+
+for (let index = 0; index < tasks.length; index += 1) {
+  const start = tasks[index].index;
+  const end = tasks[index + 1]?.index ?? text.length;
+  const block = text.slice(start, end);
+  const title = tasks[index][0];
+
+  if (/^- \[[ x]\] F\d\./.test(title)) {
+    assert.match(block, /(?:Commands?|Tool):/, `${title} missing command or tool`);
+    assert.match(block, /(?:Expected|Pass):/, `${title} missing expected result`);
+  } else {
+    assert.match(title, /^- \[x\]/, `${title} is not complete`);
+    assert.match(block, /\*\*References\*\*:/, `${title} missing references`);
+    assert.match(block, /\*\*Acceptance Criteria\*\*:/, `${title} missing acceptance criteria`);
+    assert.match(block, /\*\*QA Scenarios\*\*:/, `${title} missing QA scenarios`);
+    assert.match(block, /\*\*Commit\*\*:/, `${title} missing commit metadata`);
+  }
+}
+
+process.stdout.write(`PLAN_AUDIT_PASS: ${tasks.length} checked items complete\n`);

package/scripts/doctor.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+
+function run(label, command, args) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    encoding: "utf8",
+  });
+
+  process.stdout.write(`\n## ${label}\n`);
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stdout.write(result.stderr);
+
+  if (result.status !== 0) {
+    process.stderr.write(`${label} failed with status ${result.status}\n`);
+    process.exit(result.status ?? 1);
+  }
+}
+
+run("CLI dry-run", process.execPath, ["bin/litclaude-ai.js", "--dry-run", "doctor"]);
+run("Plugin validation", process.execPath, ["scripts/validate-plugin.mjs"]);
+run("LSP doctor", process.execPath, ["plugins/litclaude/bin/litclaude-lsp-doctor.js"]);
+
+for (const file of [
+  "plugins/litclaude/lib/litgoal/paths.mjs",
+  "plugins/litclaude/lib/litgoal/state.mjs",
+  "plugins/litclaude/lib/litgoal/ledger.mjs",
+  "plugins/litclaude/lib/litgoal/cli.mjs",
+]) {
+  if (!existsSync(join(root, file))) {
+    process.stderr.write(`Runtime payload missing: ${file}\n`);
+    process.exit(1);
+  }
+}
+process.stdout.write("\nLITGOAL_RUNTIME_PASS\n");
+process.stdout.write("\nDOCTOR_PASS\n");

package/scripts/inspect-agent-tools.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+
+const path = process.argv[2];
+
+if (!path) {
+  console.error("Usage: inspect-agent-tools.mjs <agent-file>");
+  process.exit(64);
+}
+
+const text = readFileSync(path, "utf8");
+const match = /^---\n([\s\S]*?)\n---/u.exec(text);
+
+if (!match) {
+  console.error("agent frontmatter not found");
+  process.exit(65);
+}
+
+const toolsLine = match[1].split("\n").find((line) => line.startsWith("tools:")) ?? "tools:";
+const tools = toolsLine
+  .replace("tools:", "")
+  .split(",")
+  .map((tool) => tool.trim())
+  .filter(Boolean);
+
+console.log(JSON.stringify({ path, tools }, null, 2));

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(`LitClaude postinstall skipped: ${reason}\n`);
+  process.stdout.write("Run `litclaude install` to register the Claude Code plugin and HUD.\n");
+  process.exit(0);
+};
+
+if (process.env.LITCLAUDE_AUTO_INSTALL === "0" || process.env.LITCLAUDE_POSTINSTALL_SKIP === "1") {
+  skip("disabled by environment");
+}
+
+const forced = process.env.LITCLAUDE_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", "litclaude-ai.js"), "install"], {
+  cwd: root,
+  encoding: "utf8",
+  env: {
+    ...process.env,
+    LITCLAUDE_POSTINSTALL: "1",
+  },
+});
+
+if (result.status === 0) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  process.exit(0);
+}
+
+process.stdout.write("LitClaude postinstall warning: automatic Claude Code plugin/HUD setup did not complete.\n");
+if (result.stderr) process.stdout.write(result.stderr);
+process.stdout.write("Run `litclaude install` manually after npm finishes.\n");
+process.exit(0);

package/scripts/qa-claude-plugin-smoke.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+EVIDENCE="$ROOT/evidence/task-9-claude-smoke.txt"
+SESSION="litclaude-plugin-smoke-inner-$$"
+
+mkdir -p "$ROOT/evidence"
+: > "$EVIDENCE"
+
+cleanup() {
+  if command -v tmux >/dev/null 2>&1; then
+    tmux kill-session -t "$SESSION" >/dev/null 2>&1 || true
+  fi
+}
+trap cleanup EXIT INT TERM
+
+{
+  echo "LitClaude Claude Code smoke"
+  echo "ROOT: $ROOT"
+  date
+} >> "$EVIDENCE"
+
+if ! command -v claude >/dev/null 2>&1; then
+  {
+    echo "CONTROLLED_SKIP: claude executable unavailable"
+    echo "CLEANUP: no tmux session started"
+  } >> "$EVIDENCE"
+  echo "CONTROLLED_SKIP: claude executable unavailable"
+  exit 0
+fi
+
+CLAUDE_VERSION="$(claude --version 2>&1 || true)"
+echo "CLAUDE_VERSION: $CLAUDE_VERSION" >> "$EVIDENCE"
+
+if ! command -v tmux >/dev/null 2>&1; then
+  HELP_OUTPUT="$(claude --plugin-dir "$ROOT/plugins/litclaude" --help 2>&1 || true)"
+  {
+    echo "CONTROLLED_SKIP: tmux unavailable"
+    echo "$HELP_OUTPUT" | sed -n '1,40p'
+    echo "CLEANUP: no tmux session started"
+  } >> "$EVIDENCE"
+  echo "CONTROLLED_SKIP: tmux unavailable"
+  exit 0
+fi
+
+tmux new-session -d -s "$SESSION" "cd '$ROOT' && claude --plugin-dir ./plugins/litclaude --help; printf '\nINNER_STATUS:%s\n' \"\$?\"; sleep 5"
+sleep 1
+tmux capture-pane -pt "$SESSION" -S -200 >> "$EVIDENCE" 2>&1 || true
+tmux kill-session -t "$SESSION" >/dev/null 2>&1 || true
+
+if rg -q "INNER_STATUS:0|Usage|Claude Code" "$EVIDENCE"; then
+  echo "SMOKE_PASS: claude --plugin-dir accepted local LitClaude plugin path" >> "$EVIDENCE"
+  echo "CLEANUP: $SESSION killed" >> "$EVIDENCE"
+  echo "SMOKE_PASS: claude --plugin-dir accepted local LitClaude plugin path"
+else
+  echo "CONTROLLED_SKIP: claude help did not expose a stable plugin-dir smoke result" >> "$EVIDENCE"
+  echo "CLEANUP: $SESSION killed" >> "$EVIDENCE"
+  echo "CONTROLLED_SKIP: claude help did not expose a stable plugin-dir smoke result"
+fi

package/scripts/qa-portable-install.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -u
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+EVIDENCE="$ROOT/evidence/portable-qa-install.txt"
+TMP_HOME=""
+TMP_CLAUDE_HOME=""
+
+mkdir -p "$ROOT/evidence"
+: > "$EVIDENCE"
+
+cleanup() {
+  if [ -n "$TMP_HOME" ]; then
+    rm -rf "$TMP_HOME"
+  fi
+  if [ -n "$TMP_CLAUDE_HOME" ]; then
+    rm -rf "$TMP_CLAUDE_HOME"
+  fi
+}
+trap cleanup EXIT INT TERM
+
+{
+  echo "LitClaude portable install QA"
+  echo "ROOT: $ROOT"
+  date
+} >> "$EVIDENCE"
+
+TMP_HOME="$(mktemp -d "${TMPDIR:-/tmp/}litclaude-portable-qa.XXXXXX")"
+TMP_CLAUDE_HOME="$(mktemp -d "${TMPDIR:-/tmp/}litclaude-claude-qa.XXXXXX")"
+export LITCLAUDE_HOME="$TMP_HOME"
+export CLAUDE_CONFIG_DIR="$TMP_CLAUDE_HOME"
+
+run_step() {
+  local label="$1"
+  shift
+  local status
+  {
+    echo
+    echo "## $label"
+    "$@"
+    status="$?"
+    echo "STATUS:$status"
+  } >> "$EVIDENCE" 2>&1
+  if [ "$status" != "0" ]; then
+    echo "${label}_FAIL"
+    exit "$status"
+  fi
+}
+
+run_step INSTALL node "$ROOT/bin/litclaude-ai.js" install
+
+PLUGIN_PATH="$(node "$ROOT/bin/litclaude-ai.js" path)"
+{
+  echo
+  echo "## PATH"
+  echo "$PLUGIN_PATH"
+} >> "$EVIDENCE"
+
+if [ ! -f "$PLUGIN_PATH/.claude-plugin/plugin.json" ]; then
+  echo "INSTALL_FAIL: plugin manifest missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+for runtime_file in \
+  "$PLUGIN_PATH/lib/litgoal/paths.mjs" \
+  "$PLUGIN_PATH/lib/litgoal/state.mjs" \
+  "$PLUGIN_PATH/lib/litgoal/ledger.mjs" \
+  "$PLUGIN_PATH/lib/litgoal/cli.mjs"
+do
+  if [ ! -f "$runtime_file" ]; then
+    echo "INSTALL_FAIL: litgoal runtime missing: $runtime_file" >> "$EVIDENCE"
+    echo "INSTALL_FAIL"
+    exit 1
+  fi
+done
+echo "LITGOAL_RUNTIME_PASS" >> "$EVIDENCE"
+if [ ! -f "$TMP_CLAUDE_HOME/plugins/installed_plugins.json" ]; then
+  echo "INSTALL_FAIL: Claude plugin registry missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+if [ ! -f "$TMP_CLAUDE_HOME/settings.json" ]; then
+  echo "INSTALL_FAIL: Claude settings missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+if [ ! -f "$TMP_CLAUDE_HOME/plugins/known_marketplaces.json" ]; then
+  echo "INSTALL_FAIL: Claude known marketplaces missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+if [ ! -f "$TMP_HOME/marketplaces/litclaude-ai/.claude-plugin/marketplace.json" ]; then
+  echo "INSTALL_FAIL: LitClaude local marketplace missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+node -e 'const fs = require("fs"); const p = process.argv[1]; const registry = JSON.parse(fs.readFileSync(`${p}/plugins/installed_plugins.json`, "utf8")); const entry = registry.plugins["litclaude@litclaude-ai"]?.[0]; if (!entry || entry.scope !== "user" || !entry.installPath.includes("/plugins/cache/litclaude-ai/litclaude/")) process.exit(1);' "$TMP_CLAUDE_HOME"
+node -e 'const fs = require("fs"); const p = process.argv[1]; const h = process.argv[2]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); const market = settings.extraKnownMarketplaces?.["litclaude-ai"]; if (settings.enabledPlugins?.["litclaude@litclaude-ai"] !== true || market?.source?.source !== "directory" || market.source.path !== `${h}/marketplaces/litclaude-ai`) process.exit(1);' "$TMP_CLAUDE_HOME" "$TMP_HOME"
+node -e 'const fs = require("fs"); const p = process.argv[1]; const h = process.argv[2]; const known = JSON.parse(fs.readFileSync(`${p}/plugins/known_marketplaces.json`, "utf8")); const market = known["litclaude-ai"]; if (market?.source?.source !== "directory" || market.installLocation !== `${h}/marketplaces/litclaude-ai`) process.exit(1);' "$TMP_CLAUDE_HOME" "$TMP_HOME"
+echo "INSTALL_PASS" >> "$EVIDENCE"
+
+run_step DOCTOR node "$ROOT/bin/litclaude-ai.js" doctor
+echo "DOCTOR_PASS" >> "$EVIDENCE"
+
+if command -v claude >/dev/null 2>&1; then
+  run_step CLAUDE_PLUGIN_DETAILS claude plugin details litclaude@litclaude-ai
+  if ! grep -Eq "Skills \\([0-9]+\\)" "$EVIDENCE" || ! grep -q "lit-loop" "$EVIDENCE" || ! grep -q "lit-plan" "$EVIDENCE" || ! grep -q "Hooks (4)" "$EVIDENCE"; then
+    echo "CLAUDE_PLUGIN_DETAILS_FAIL: expected LitClaude skills/hooks inventory" >> "$EVIDENCE"
+    echo "CLAUDE_PLUGIN_DETAILS_FAIL"
+    exit 1
+  fi
+else
+  echo "CLAUDE_PLUGIN_DETAILS_SKIP: claude executable not found" >> "$EVIDENCE"
+fi
+
+run_step DRY_RUN_UNINSTALL node "$ROOT/bin/litclaude-ai.js" --dry-run uninstall
+if [ ! -d "$PLUGIN_PATH" ]; then
+  echo "DRY_RUN_UNINSTALL_FAIL: plugin removed during dry-run" >> "$EVIDENCE"
+  exit 1
+fi
+
+run_step UNINSTALL node "$ROOT/bin/litclaude-ai.js" uninstall
+if [ -e "$TMP_HOME/current" ] || [ -e "$TMP_HOME/litclaude-ai" ] || [ -e "$TMP_CLAUDE_HOME/plugins/cache/litclaude-ai" ]; then
+  echo "UNINSTALL_FAIL: managed state remains" >> "$EVIDENCE"
+  echo "UNINSTALL_FAIL"
+  exit 1
+fi
+node -e 'const fs = require("fs"); const p = process.argv[1]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); if (settings.enabledPlugins?.["litclaude@litclaude-ai"] !== undefined) process.exit(1);' "$TMP_CLAUDE_HOME"
+node -e 'const fs = require("fs"); const p = process.argv[1]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); const known = JSON.parse(fs.readFileSync(`${p}/plugins/known_marketplaces.json`, "utf8")); if (settings.extraKnownMarketplaces?.["litclaude-ai"] !== undefined || known["litclaude-ai"] !== undefined) process.exit(1);' "$TMP_CLAUDE_HOME"
+echo "UNINSTALL_PASS" >> "$EVIDENCE"
+
+cleanup
+TMP_HOME=""
+TMP_CLAUDE_HOME=""
+echo "CLEANUP: removed portable QA temp home" >> "$EVIDENCE"
+echo "PORTABLE_QA_PASS"

package/scripts/validate-plugin.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { access, readdir, readFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const pluginRoot = join(root, "plugins", "litclaude");
+
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function exists(path) {
+  await access(path, constants.R_OK);
+}
+
+async function main() {
+  const manifest = await readJson(join(pluginRoot, ".claude-plugin", "plugin.json"));
+  assert.equal(manifest.name, "litclaude");
+  assert.equal(manifest.skills, "./skills");
+  assert.deepEqual(manifest.agents, [
+    "./agents/boulder-executor.md",
+    "./agents/librarian-researcher.md",
+    "./agents/oracle-verifier.md",
+    "./agents/prometheus-planner.md",
+    "./agents/qa-runner.md",
+    "./agents/quality-reviewer.md",
+  ]);
+  assert.equal("hooks" in manifest, false);
+  assert.equal(manifest.mcpServers, "./.mcp.json");
+  assert.equal(manifest.lspServers, "./.lsp.json");
+
+  await exists(join(pluginRoot, ".mcp.json"));
+  await exists(join(pluginRoot, ".lsp.json"));
+  await exists(join(pluginRoot, "bin", "litclaude-hook.js"));
+  await exists(join(pluginRoot, "bin", "litclaude-lsp-doctor.js"));
+  await exists(join(pluginRoot, "bin", "litclaude-mcp.js"));
+
+  const hooks = await readJson(join(pluginRoot, "hooks", "hooks.json"));
+  for (const event of ["SessionStart", "UserPromptSubmit", "PostToolUse", "PostCompact"]) {
+    assert.ok(hooks.hooks[event], `missing hook event ${event}`);
+  }
+
+  const skills = await readdir(join(pluginRoot, "skills"));
+  const agents = await readdir(join(pluginRoot, "agents"));
+  assert.ok(skills.length >= 7, "expected at least seven skills");
+  assert.ok(agents.length >= 6, "expected at least six agents");
+
+  const claude = spawnSync("claude", ["--version"], { encoding: "utf8" });
+  if (claude.status === 0) {
+    process.stdout.write(`CLAUDE_VERSION: ${claude.stdout.trim() || claude.stderr.trim()}\n`);
+    const validation = spawnSync("claude", ["plugin", "validate", "./plugins/litclaude"], {
+      cwd: root,
+      encoding: "utf8",
+    });
+    if (validation.stdout) process.stdout.write(validation.stdout);
+    if (validation.stderr) process.stdout.write(validation.stderr);
+    assert.equal(validation.status, 0, "claude plugin validate must pass");
+  } else {
+    process.stdout.write("CONTROLLED_SKIP: claude executable unavailable for version probe\n");
+  }
+
+  process.stdout.write("VALIDATE_PLUGIN_PASS\n");
+}
+
+main().catch((error) => {
+  process.stderr.write(`VALIDATE_PLUGIN_FAIL: ${error.message}\n`);
+  process.exit(1);
+});