claude-launchpad 1.8.0 → 1.9.0

package/dist/{chunk-7QPZN27I.js → chunk-RCYLZUU6.js}

@@ -32,77 +32,15 @@ async function readJsonOrNull(path) {
 }
 
 // src/lib/settings.ts
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-async function readSettingsJson(root) {
-  const path = join(root, ".claude", "settings.json");
-  try {
-    const content = await readFile2(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function writeSettingsJson(root, settings) {
-  const dir = join(root, ".claude");
-  await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
-}
-async function readSettingsLocalJson(root) {
-  const path = join(root, ".claude", "settings.local.json");
-  try {
-    const content = await readFile2(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function writeSettingsLocalJson(root, settings) {
-  const dir = join(root, ".claude");
-  await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, "settings.local.json"), JSON.stringify(settings, null, 2) + "\n");
-}
-
-// src/lib/memory-placement.ts
-import { select } from "@inquirer/prompts";
-function hasMemoryPermissions(settings) {
-  const permissions = settings.permissions;
-  const allow = permissions?.allow ?? [];
-  return allow.some((p) => p.includes("agentic-memory"));
-}
-async function getMemoryPlacement(root, skipPrompt = false) {
-  const local = await readSettingsLocalJson(root);
-  const persisted = local.memoryPlacement;
-  if (persisted === "shared" || persisted === "local") {
-    return persisted;
-  }
-  if (hasMemoryPermissions(local)) {
-    await writeSettingsLocalJson(root, { ...local, memoryPlacement: "local" });
-    return "local";
-  }
-  const shared = await readSettingsJson(root);
-  if (hasMemoryPermissions(shared)) {
-    await writeSettingsLocalJson(root, { ...local, memoryPlacement: "shared" });
-    return "shared";
-  }
-  if (skipPrompt) return "shared";
-  const choice = await select({
-    message: "Where should memory config go?",
-    choices: [
-      { value: "shared", name: "Shared (team sees it) \u2014 CLAUDE.md + settings.json" },
-      { value: "local", name: "Local (only you) \u2014 .claude/CLAUDE.md + settings.local.json" }
-    ]
-  });
-  await writeSettingsLocalJson(root, { ...local, memoryPlacement: choice });
-  return choice;
-}
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/lib/output.ts
 import chalk from "chalk";
 
 // src/commands/doctor/fixer.ts
-import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2, access as access2 } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2, access as access2 } from "fs/promises";
+import { join as join5 } from "path";
 import { homedir } from "os";
 
 // src/lib/sections.ts
@@ -113,22 +51,22 @@ var OFF_LIMITS_CONTENT = "- Never hardcode secrets \u2014 use environment variab
 var SKILL_AUTHORING_CONTENT = 'When creating Claude Code skills (.claude/skills/*/SKILL.md):\n\n- Keep SKILL.md under 500 lines \u2014 move reference material to supporting files in the same directory\n- Front-load description (first 250 chars shown in listings) with TRIGGER when / DO NOT TRIGGER when clauses\n- Add allowed-tools in frontmatter to restrict tool access (e.g. Read, Glob, Grep for read-only skills)\n- Add argument-hint in frontmatter showing the expected input format (use $ARGUMENTS or $0, $1 for dynamic input)\n- Set disable-model-invocation: true for skills with side effects (deploy, send messages)\n- Structure as phases: Research, Plan, Execute, Verify with "Done when:" success criteria per phase\n- Handle edge cases and preconditions before execution';
 
 // src/lib/detect.ts
-import { join as join2, basename } from "path";
+import { join, basename } from "path";
 async function detectProject(root) {
   const name = basename(root);
   const [pkgJson, goMod, pyProject, gemfile, cargo, pubspec, composerJson, pomXml, buildGradleGroovy, buildGradleKts, packageSwift, mixExs, csproj, lockfiles] = await Promise.all([
-    readJsonOrNull(join2(root, "package.json")),
-    fileExists(join2(root, "go.mod")),
-    readFileOrNull(join2(root, "pyproject.toml")),
-    fileExists(join2(root, "Gemfile")),
-    fileExists(join2(root, "Cargo.toml")),
-    fileExists(join2(root, "pubspec.yaml")),
-    readJsonOrNull(join2(root, "composer.json")),
-    fileExists(join2(root, "pom.xml")),
-    fileExists(join2(root, "build.gradle")),
-    fileExists(join2(root, "build.gradle.kts")),
-    fileExists(join2(root, "Package.swift")),
-    fileExists(join2(root, "mix.exs")),
+    readJsonOrNull(join(root, "package.json")),
+    fileExists(join(root, "go.mod")),
+    readFileOrNull(join(root, "pyproject.toml")),
+    fileExists(join(root, "Gemfile")),
+    fileExists(join(root, "Cargo.toml")),
+    fileExists(join(root, "pubspec.yaml")),
+    readJsonOrNull(join(root, "composer.json")),
+    fileExists(join(root, "pom.xml")),
+    fileExists(join(root, "build.gradle")),
+    fileExists(join(root, "build.gradle.kts")),
+    fileExists(join(root, "Package.swift")),
+    fileExists(join(root, "mix.exs")),
     globExists(root, "*.csproj"),
     detectLockfiles(root)
   ]);
@@ -209,10 +147,10 @@ function detectFramework(m) {
 }
 async function detectLockfiles(root) {
   const [pnpmLock, yarnLock, bunLock, npmLock] = await Promise.all([
-    fileExists(join2(root, "pnpm-lock.yaml")),
-    fileExists(join2(root, "yarn.lock")),
-    fileExists(join2(root, "bun.lockb")),
-    fileExists(join2(root, "package-lock.json"))
+    fileExists(join(root, "pnpm-lock.yaml")),
+    fileExists(join(root, "yarn.lock")),
+    fileExists(join(root, "bun.lockb")),
+    fileExists(join(root, "package-lock.json"))
   ]);
   return { pnpmLock, yarnLock, bunLock, npmLock };
 }
@@ -619,6 +557,40 @@ function generateEnhanceSkill() {
   ].join("\n");
 }
 
+// src/lib/memory-placement.ts
+import { select } from "@inquirer/prompts";
+function hasMemoryPermissions(settings) {
+  const permissions = settings.permissions;
+  const allow = permissions?.allow ?? [];
+  return allow.some((p) => p.includes("agentic-memory"));
+}
+async function getMemoryPlacement(root, skipPrompt = false) {
+  const local = await readSettingsLocalJson(root) ?? {};
+  const persisted = local.memoryPlacement;
+  if (persisted === "shared" || persisted === "local") {
+    return persisted;
+  }
+  if (hasMemoryPermissions(local)) {
+    await writeSettingsLocalJson(root, { ...local, memoryPlacement: "local" });
+    return "local";
+  }
+  const shared = await readSettingsJson(root) ?? {};
+  if (hasMemoryPermissions(shared)) {
+    await writeSettingsLocalJson(root, { ...local, memoryPlacement: "shared" });
+    return "shared";
+  }
+  if (skipPrompt) return "shared";
+  const choice = await select({
+    message: "Where should memory config go?",
+    choices: [
+      { value: "shared", name: "Shared (team sees it) \u2014 CLAUDE.md + settings.json" },
+      { value: "local", name: "Local (only you) \u2014 .claude/CLAUDE.md + settings.local.json" }
+    ]
+  });
+  await writeSettingsLocalJson(root, { ...local, memoryPlacement: choice });
+  return choice;
+}
+
 // src/lib/stub-marker.ts
 var LP_STUB_OPEN = "<!-- LP-STUB: ai-recommended -->";
 var LP_STUB_CLOSE = "<!-- /LP-STUB -->";
@@ -628,23 +600,236 @@ ${content}
 ${LP_STUB_CLOSE}`;
 }
 
-// src/commands/doctor/fixer-memory.ts
-import { readFile as readFile3 } from "fs/promises";
+// src/commands/doctor/fixer-sprint.ts
+import { writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
+
+// src/lib/hook-builder.ts
+function addOrUpdateHook(existingHooks, options) {
+  const hookList = existingHooks?.[options.event] ?? [];
+  const alreadyHas = hookList.some((group) => {
+    const nested = group.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes(options.dedupKeyword));
+  });
+  if (alreadyHas) {
+    return { hooks: existingHooks ?? {}, added: false };
+  }
+  const newEntry = options.entry;
+  const updated = options.prepend ? [newEntry, ...hookList] : [...hookList, newEntry];
+  return {
+    hooks: { ...existingHooks ?? {}, [options.event]: updated },
+    added: true
+  };
+}
+async function addHookToSettings(root, event, dedupKeyword, entry, successMsg) {
+  const settings = await readSettingsJson(root);
+  if (settings === null) return false;
+  const existingHooks = settings.hooks;
+  const result = addOrUpdateHook(existingHooks, { event, dedupKeyword, entry });
+  if (!result.added) return false;
+  await writeSettingsJson(root, { ...settings, hooks: result.hooks });
+  log.success(successMsg);
+  return true;
+}
+
+// src/lib/hook-scripts.ts
+import { writeFile, mkdir, chmod } from "fs/promises";
+import { join as join2 } from "path";
+var SPRINT_SIZE_CHECK = `#!/usr/bin/env bash
+# Warns when the current sprint is too small (<3) or too large (>7).
+# Sweet spot is 3-6 work packages per sprint. Non-blocking (always exits 0).
+
+set -u
+tasks="\${1:-TASKS.md}"
+[ -f "$tasks" ] || exit 0
+
+section=$(sed -n '/^## Current/,/^## /p' "$tasks" 2>/dev/null)
+[ -z "$section" ] && exit 0
+
+unchecked=$(echo "$section" | grep -cF -e '- [ ]' || true)
+checked=$(echo "$section" | grep -cF -e '- [x]' || true)
+total=$((unchecked + checked))
+
+if [ "$total" -eq 0 ]; then
+  echo "NOTE: Current sprint has no work packages yet. Pull 3-6 from BACKLOG.md to start."
+  exit 0
+fi
+
+if [ "$unchecked" -eq 0 ]; then exit 0; fi
+
+if [ "$unchecked" -lt 3 ]; then
+  echo "NOTE: Current sprint has $unchecked open work package(s) \u2014 that's a microsprint. Pull from BACKLOG.md (aim 3-6)."
+  exit 0
+fi
+
+if [ "$unchecked" -gt 7 ]; then
+  echo "NOTE: Current sprint has $unchecked open work packages \u2014 oversized. Move some back to BACKLOG.md (aim 3-6)."
+  exit 0
+fi
+
+exit 0
+`;
+var SPRINT_OPEN_CHECK = `#!/usr/bin/env bash
+# Warns when TASKS.md opens a new sprint block but BACKLOG.md has no staged
+# deletions, i.e. the "remove pulled WPs from BACKLOG in the same edit" rule
+# from CLAUDE.md was skipped. Non-blocking (always exits 0).
+
+set -u
+cmd="\${TOOL_INPUT_COMMAND:-}"
+
+# Only act on \`git commit\`, word-boundary match.
+echo "$cmd" | grep -qE '(^|[^a-zA-Z0-9_-])git[[:space:]]+commit([[:space:]]|$)' || exit 0
+
+# Nothing staged
+git diff --cached --quiet 2>/dev/null && exit 0
+
+# TASKS.md not staged
+git diff --cached --name-only --diff-filter=ACM 2>/dev/null | grep -q '^TASKS\\.md$' || exit 0
+
+# Does the staged TASKS.md diff ADD a new \`## Current\` block?
+new_sprint=$(git diff --cached TASKS.md 2>/dev/null | grep -cE '^\\+## Current')
+[ "$new_sprint" -eq 0 ] && exit 0
+
+# If a new sprint was opened, BACKLOG.md should have net deletions.
+backlog_deletions=$(git diff --cached BACKLOG.md 2>/dev/null | grep -cE '^-[^-]')
+if [ "$backlog_deletions" -eq 0 ]; then
+  echo ""
+  echo "WARNING: sprint-open hygiene"
+  echo ""
+  echo "TASKS.md stages a new '## Current' block, but BACKLOG.md has no"
+  echo "staged deletions. When a WP is pulled from BACKLOG.md into a sprint,"
+  echo "remove it from BACKLOG.md in the same edit. Overlap = drift."
+  echo ""
+  echo "If you opened a fresh-scope sprint with no BACKLOG pulls, ignore"
+  echo "this. Otherwise scrub BACKLOG.md before committing."
+  echo ""
+fi
+
+exit 0
+`;
+async function writeSprintHygieneScripts(root) {
+  const hooksDir = join2(root, ".claude", "hooks");
+  await mkdir(hooksDir, { recursive: true });
+  const sizePath = join2(hooksDir, "sprint-size-check.sh");
+  const openPath = join2(hooksDir, "sprint-open-check.sh");
+  await writeFile(sizePath, SPRINT_SIZE_CHECK);
+  await writeFile(openPath, SPRINT_OPEN_CHECK);
+  await chmod(sizePath, 493);
+  await chmod(openPath, 493);
+  return { sizePath, openPath };
+}
+
+// src/commands/doctor/fixer-sprint.ts
+var WORKTREE_INCLUDE_TEMPLATE = `# Files copied into git worktrees that Claude Code creates for subagents.
+# Listed files must be gitignored \u2014 that's the point: keep secrets out of
+# commits while letting worktree subagents inherit local env so dev servers,
+# tests, and integration runs work the same as the main tree.
+# Anything needed by \`pnpm dev\`, \`pnpm test\`, etc. that's NOT committed
+# should land here.
+
+.env.local
+.env
+`;
+async function createWorktreeInclude(root) {
+  await writeFile2(join3(root, ".worktreeinclude"), WORKTREE_INCLUDE_TEMPLATE);
+  log.success("Generated .worktreeinclude (worktree subagents inherit .env.local / .env)");
+  return true;
+}
+async function addSprintSizeHook(root) {
+  await writeSprintHygieneScripts(root);
+  return addHookToSettings(root, "SessionStart", "sprint-size-check.sh", {
+    matcher: "startup|resume",
+    hooks: [{ type: "command", command: "bash .claude/hooks/sprint-size-check.sh TASKS.md 2>/dev/null; exit 0" }]
+  }, "Added sprint-size-check hook (warns on microsprint/oversized sprints)");
+}
+async function addSprintOpenHook(root) {
+  await writeSprintHygieneScripts(root);
+  return addHookToSettings(root, "PreToolUse", "sprint-open-check.sh", {
+    matcher: "Bash",
+    hooks: [{ type: "command", command: "bash .claude/hooks/sprint-open-check.sh 2>/dev/null; exit 0" }]
+  }, "Added sprint-open-check hook (warns on new sprint without BACKLOG cleanup)");
+}
+async function addSprintCompleteNudge(root) {
+  return addHookToSettings(root, "PostToolUse", "Sprint complete", {
+    matcher: "Edit|Write",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -q TASKS.md || exit 0; section=$(sed -n '/^## Current/,/^## /p' TASKS.md 2>/dev/null); [ -z "$section" ] && exit 0; unchecked=$(echo "$section" | grep -cF '- [ ]' || true); checked=$(echo "$section" | grep -cF '- [x]' || true); [ "$unchecked" -eq 0 ] && [ "$checked" -gt 0 ] && echo 'Sprint complete \u2014 all current tasks done. Consider a quick quality check before committing: scan for dead code, debug artifacts, TODO hacks, and convention violations. Run tests if available. Skip if trivial.'; exit 0`
+    }]
+  }, "Added sprint-complete nudge hook");
+}
+
+// src/commands/doctor/fixer-hooks.ts
+var FORMATTERS = {
+  TypeScript: { extensions: ["ts", "tsx"], command: "npx prettier --write" },
+  JavaScript: { extensions: ["js", "jsx"], command: "npx prettier --write" },
+  Python: { extensions: ["py"], command: "ruff format" },
+  Go: { extensions: ["go"], command: "gofmt -w" },
+  Rust: { extensions: ["rs"], command: "rustfmt" },
+  Ruby: { extensions: ["rb"], command: "rubocop -A" },
+  PHP: { extensions: ["php"], command: "vendor/bin/pint" }
+};
+async function addEnvProtectionHook(root) {
+  return addHookToSettings(root, "PreToolUse", ".env", {
+    matcher: "Read|Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets' && exit 1; exit 0`
+    }]
+  }, "Added .env file protection hook (PreToolUse)");
+}
+async function addAutoFormatHook(root, detected) {
+  if (!detected.language) return false;
+  const config = detected.language ? FORMATTERS[detected.language] : null;
+  if (!config) return false;
+  const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
+  return addHookToSettings(root, "PostToolUse", "format", {
+    matcher: "Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
+    }]
+  }, `Added auto-format hook (PostToolUse \u2192 ${config.command})`);
+}
+async function addForcePushProtection(root) {
+  return addHookToSettings(root, "PreToolUse", "force", {
+    matcher: "Bash",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_COMMAND" | grep -qE 'push.*--force|push.*-f' && echo 'WARNING: Force push detected \u2014 this can destroy remote history' && exit 1; exit 0`
+    }]
+  }, "Added force-push protection hook (PreToolUse \u2192 Bash)");
+}
+async function addPostCompactHook(root) {
+  return addHookToSettings(root, "PostCompact", "TASKS.md", {
+    matcher: "",
+    hooks: [{ type: "command", command: "cat TASKS.md 2>/dev/null; exit 0" }]
+  }, "Added PostCompact hook (re-injects TASKS.md after compaction)");
+}
+async function addSessionStartHook(root) {
+  return addHookToSettings(root, "SessionStart", "TASKS.md", {
+    matcher: "startup|resume",
+    hooks: [{ type: "command", command: "cat TASKS.md 2>/dev/null; exit 0" }]
+  }, "Added SessionStart hook (injects TASKS.md at startup)");
+}
+
+// src/commands/doctor/fixer-memory.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
 async function addPlacementHook(root, placement, event, dedupKeyword, entry, prepend, successMsg) {
   const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
   const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
   const settings = await read(root);
-  const hooks = settings.hooks ?? {};
-  const hookList = hooks[event] ?? [];
-  const alreadyHas = hookList.some((g) => {
-    const nested = g.hooks;
-    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
+  if (settings === null) return false;
+  const existingHooks = settings.hooks;
+  const result = addOrUpdateHook(existingHooks, {
+    event,
+    dedupKeyword,
+    entry,
+    prepend
   });
-  if (alreadyHas) return false;
-  const updatedList = prepend ? [entry, ...hookList] : [...hookList, entry];
-  const updatedSettings = { ...settings, hooks: { ...hooks, [event]: updatedList } };
-  await write(root, updatedSettings);
+  if (!result.added) return false;
+  await write(root, { ...settings, hooks: result.hooks });
   log.success(successMsg);
   return true;
 }
@@ -652,6 +837,7 @@ async function disableAutoMemory(root, placement) {
   const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
   const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
   const settings = await read(root);
+  if (settings === null) return false;
   if (settings.autoMemoryEnabled === false) return false;
   const updated = { ...settings, autoMemoryEnabled: false };
   await write(root, updated);
@@ -663,6 +849,7 @@ async function addMemoryToolPermissions(root, placement) {
   const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
   const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
   const settings = await read(root);
+  if (settings === null) return false;
   const permissions = settings.permissions ?? {};
   const allow = permissions.allow ?? [];
   const tools = [
@@ -701,6 +888,7 @@ async function upgradeStaleSessionEndPushHook(root) {
     const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
     const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
     const settings = await read(root);
+    if (settings === null) continue;
     const hooks = settings.hooks;
     const sessionEnd = hooks?.SessionEnd;
     if (!sessionEnd) continue;
@@ -727,6 +915,7 @@ async function upgradeStaleSessionEndPushHook(root) {
 }
 async function removeStaleStopHook(root) {
   const settings = await readSettingsJson(root);
+  if (settings === null) return false;
   const hooks = settings.hooks;
   if (!hooks?.Stop) return false;
   const stopHooks = hooks.Stop;
@@ -749,6 +938,7 @@ async function addMemoryToAllowedMcpServers(root) {
     const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
     const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
     const settings = await read(root);
+    if (settings === null) continue;
     const existing = settings.allowedMcpServers;
     if (!Array.isArray(existing)) continue;
     const list = existing;
@@ -769,17 +959,19 @@ async function addAllowedMcpServers(root, placement) {
   const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
   const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
   const settings = await read(root);
+  if (settings === null) return false;
   if (settings.allowedMcpServers) return false;
   const other = placement === "local" ? await readSettingsJson(root) : await readSettingsLocalJson(root);
+  if (other === null) return false;
   if (other.allowedMcpServers) return false;
   const serverNames = /* @__PURE__ */ new Set();
   const settingsServers = settings.mcpServers;
   if (settingsServers && typeof settingsServers === "object") {
     for (const name of Object.keys(settingsServers)) serverNames.add(name);
   }
-  const mcpJsonPath = join3(root, ".mcp.json");
+  const mcpJsonPath = join4(root, ".mcp.json");
   try {
-    const mcpJson = JSON.parse(await readFile3(mcpJsonPath, "utf-8"));
+    const mcpJson = JSON.parse(await readFile2(mcpJsonPath, "utf-8"));
     const mcpServers = mcpJson.mcpServers;
     if (mcpServers && typeof mcpServers === "object") {
       for (const name of Object.keys(mcpServers)) serverNames.add(name);
@@ -849,6 +1041,10 @@ var FIX_TABLE = [
   { analyzer: "Permissions", match: "Bypass permissions mode", fix: (root) => addBypassDisable(root) },
   { analyzer: "Permissions", match: "Filesystem sandbox enabled", fix: (root) => removeSandboxSettings(root) },
   { analyzer: "Permissions", match: ".env is protected by hooks but not in .claudeignore", fix: (root) => addEnvToClaudeignore(root) },
+  { analyzer: "Permissions", match: ".worktreeinclude is missing or empty", fix: (root) => createWorktreeInclude(root) },
+  { analyzer: "Hooks", match: "sprint-size-check", fix: (root) => addSprintSizeHook(root) },
+  { analyzer: "Hooks", match: "sprint-open-check", fix: (root) => addSprintOpenHook(root) },
+  { analyzer: "Hooks", match: "sprint-complete nudge", fix: (root) => addSprintCompleteNudge(root) },
   { analyzer: "Rules", match: "No skill authoring conventions", fix: (root) => addSkillAuthoringConventions(root) },
   { analyzer: "Rules", match: "No /lp-enhance skill", fix: (root) => createEnhanceSkill(root) },
   { analyzer: "Rules", match: "lp-enhance skill is outdated", fix: (root) => updateEnhanceSkill(root) },
@@ -864,7 +1060,7 @@ var FIX_TABLE = [
   { analyzer: "Memory", match: "SessionEnd push hook is not nohup-wrapped", fix: (root) => upgradeStaleSessionEndPushHook(root) },
   { analyzer: "Memory", match: "CLAUDE.md missing memory guidance", fix: (root, _det, placement) => {
     const content = "Use agentic-memory to persist knowledge across sessions:\n- Memories are automatically injected at session start\n- STORE IMMEDIATELY when: a dependency strategy changes, an architecture decision is made, a convention is established, a bug pattern is discovered, or a feature is killed/added\n- Use memory_search before memory_store to check for duplicates\n- NEVER store credentials, API keys, tokens, or secrets in memories";
-    const target = placement === "local" ? join4(root, ".claude", "CLAUDE.md") : void 0;
+    const target = placement === "local" ? join5(root, ".claude", "CLAUDE.md") : void 0;
     return addClaudeMdSection(root, "## Memory", wrapStub(content), target);
   } }
 ];
@@ -879,81 +1075,9 @@ async function tryFix(issue, root, detected, placement) {
   );
   return entry ? entry.fix(root, detected, placement) : false;
 }
-async function addHook(root, event, dedupKeyword, entry, successMsg) {
-  const settings = await readSettingsJson(root);
-  const hooks = settings.hooks ?? {};
-  const hookList = hooks[event] ?? [];
-  const alreadyHas = hookList.some((g) => {
-    const nested = g.hooks;
-    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
-  });
-  if (alreadyHas) return false;
-  const updated = [...hookList, entry];
-  const updatedSettings = { ...settings, hooks: { ...hooks, [event]: updated } };
-  await writeSettingsJson(root, updatedSettings);
-  log.success(successMsg);
-  return true;
-}
-async function addEnvProtectionHook(root) {
-  return addHook(root, "PreToolUse", ".env", {
-    matcher: "Read|Write|Edit",
-    hooks: [{
-      type: "command",
-      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets' && exit 1; exit 0`
-    }]
-  }, "Added .env file protection hook (PreToolUse)");
-}
-async function addAutoFormatHook(root, detected) {
-  if (!detected.language) return false;
-  const formatters = {
-    TypeScript: { extensions: ["ts", "tsx"], command: "npx prettier --write" },
-    JavaScript: { extensions: ["js", "jsx"], command: "npx prettier --write" },
-    Python: { extensions: ["py"], command: "ruff format" },
-    Go: { extensions: ["go"], command: "gofmt -w" },
-    Rust: { extensions: ["rs"], command: "rustfmt" },
-    Ruby: { extensions: ["rb"], command: "rubocop -A" },
-    PHP: { extensions: ["php"], command: "vendor/bin/pint" }
-  };
-  const config = formatters[detected.language];
-  if (!config) return false;
-  const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
-  return addHook(root, "PostToolUse", "format", {
-    matcher: "Write|Edit",
-    hooks: [{
-      type: "command",
-      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
-    }]
-  }, `Added auto-format hook (PostToolUse \u2192 ${config.command})`);
-}
-async function addForcePushProtection(root) {
-  return addHook(root, "PreToolUse", "force", {
-    matcher: "Bash",
-    hooks: [{
-      type: "command",
-      command: `echo "$TOOL_INPUT_COMMAND" | grep -qE 'push.*--force|push.*-f' && echo 'WARNING: Force push detected \u2014 this can destroy remote history' && exit 1; exit 0`
-    }]
-  }, "Added force-push protection hook (PreToolUse \u2192 Bash)");
-}
-async function addPostCompactHook(root) {
-  return addHook(root, "PostCompact", "TASKS.md", {
-    matcher: "",
-    hooks: [{
-      type: "command",
-      command: "cat TASKS.md 2>/dev/null; exit 0"
-    }]
-  }, "Added PostCompact hook (re-injects TASKS.md after compaction)");
-}
-async function addSessionStartHook(root) {
-  return addHook(root, "SessionStart", "TASKS.md", {
-    matcher: "startup|resume",
-    hooks: [{
-      type: "command",
-      command: "cat TASKS.md 2>/dev/null; exit 0"
-    }]
-  }, "Added SessionStart hook (injects TASKS.md at startup)");
-}
 async function migrateAttribution(root) {
   const settings = await readSettingsJson(root);
+  if (settings === null) return false;
   if (settings.includeCoAuthoredBy === void 0) return false;
   const { includeCoAuthoredBy: _, ...rest } = settings;
   const updated = { ...rest, attribution: { commit: "", pr: "" } };
@@ -963,6 +1087,7 @@ async function migrateAttribution(root) {
 }
 async function addCredentialDenyRules(root) {
   const settings = await readSettingsJson(root);
+  if (settings === null) return false;
   const permissions = settings.permissions ?? {};
   const deny = permissions.deny ?? [];
   const toAdd = ["Read(~/.ssh/*)", "Read(~/.aws/*)", "Read(~/.npmrc)"];
@@ -975,6 +1100,7 @@ async function addCredentialDenyRules(root) {
 }
 async function addBypassDisable(root) {
   const settings = await readSettingsJson(root);
+  if (settings === null) return false;
   if (settings.disableBypassPermissionsMode === "disable") return false;
   const updated = { ...settings, disableBypassPermissionsMode: "disable" };
   await writeSettingsJson(root, updated);
@@ -983,6 +1109,7 @@ async function addBypassDisable(root) {
 }
 async function removeSandboxSettings(root) {
   const settings = await readSettingsJson(root);
+  if (settings === null) return false;
   if (settings.sandbox === void 0) return false;
   const { sandbox: _sandbox, ...rest } = settings;
   await writeSettingsJson(root, rest);
@@ -990,27 +1117,27 @@ async function removeSandboxSettings(root) {
   return true;
 }
 async function addEnvToClaudeignore(root) {
-  const ignorePath = join4(root, ".claudeignore");
+  const ignorePath = join5(root, ".claudeignore");
   let content;
   try {
-    content = await readFile4(ignorePath, "utf-8");
+    content = await readFile3(ignorePath, "utf-8");
   } catch {
     return false;
   }
   const lines = content.split("\n").map((l) => l.trim());
   if (lines.some((l) => l === ".env" || l === ".env.*" || l === ".env*")) return false;
-  await writeFile2(ignorePath, content.trimEnd() + "\n.env\n.env.*\n");
+  await writeFile3(ignorePath, content.trimEnd() + "\n.env\n.env.*\n");
   log.success("Added .env to .claudeignore");
   return true;
 }
 async function addClaudeMdSection(root, heading, content, targetPath) {
-  const claudeMdPath = targetPath ?? join4(root, "CLAUDE.md");
+  const claudeMdPath = targetPath ?? join5(root, "CLAUDE.md");
   let existing;
   try {
-    existing = await readFile4(claudeMdPath, "utf-8");
+    existing = await readFile3(claudeMdPath, "utf-8");
   } catch {
     if (!targetPath) return false;
-    await mkdir2(join4(root, ".claude"), { recursive: true });
+    await mkdir2(join5(root, ".claude"), { recursive: true });
     existing = "# Local Claude Config\n";
   }
   if (existing.includes(heading)) return false;
@@ -1022,20 +1149,20 @@ ${content}
 
 `;
   const updated = existing.slice(0, insertAt) + section + existing.slice(insertAt);
-  await writeFile2(claudeMdPath, updated);
+  await writeFile3(claudeMdPath, updated);
   const label = targetPath ? ".claude/CLAUDE.md" : "CLAUDE.md";
   log.success(`Added "${heading}" section to ${label}`);
   return true;
 }
 async function createBacklogMd(root) {
-  const backlogPath = join4(root, "BACKLOG.md");
+  const backlogPath = join5(root, "BACKLOG.md");
   try {
     await access2(backlogPath);
     return false;
   } catch {
   }
   const name = root.split("/").pop() ?? "Project";
-  await writeFile2(backlogPath, `# ${name} - Backlog
+  await writeFile3(backlogPath, `# ${name} - Backlog
 
 > Features discussed but deferred. Pick up when relevant.
 > Priority: P0 = next sprint, P1 = soon, P2 = when relevant.
@@ -1044,14 +1171,14 @@ async function createBacklogMd(root) {
   return true;
 }
 async function createClaudeignore(root, detected) {
-  const ignorePath = join4(root, ".claudeignore");
+  const ignorePath = join5(root, ".claudeignore");
   try {
     await access2(ignorePath);
     return false;
   } catch {
   }
   const content = generateClaudeignore(detected);
-  await writeFile2(ignorePath, content);
+  await writeFile3(ignorePath, content);
   log.success("Generated .claudeignore with language-specific ignore patterns");
   return true;
 }
@@ -1061,15 +1188,15 @@ var SKILL_AUTHORING_SECTION = `
 ${SKILL_AUTHORING_CONTENT}
 `;
 async function createStarterRules(root) {
-  const rulesDir = join4(root, ".claude", "rules");
+  const rulesDir = join5(root, ".claude", "rules");
   try {
     await access2(rulesDir);
     return false;
   } catch {
   }
   await mkdir2(rulesDir, { recursive: true });
-  await writeFile2(
-    join4(rulesDir, "conventions.md"),
+  await writeFile3(
+    join5(rulesDir, "conventions.md"),
     `# Project Conventions
 
 - Use conventional commits (feat:, fix:, docs:, refactor:, test:, chore:)
@@ -1082,36 +1209,36 @@ ${SKILL_AUTHORING_SECTION}`
   return true;
 }
 async function addSkillAuthoringConventions(root) {
-  const conventionsPath = join4(root, ".claude", "rules", "conventions.md");
+  const conventionsPath = join5(root, ".claude", "rules", "conventions.md");
   let content;
   try {
-    content = await readFile4(conventionsPath, "utf-8");
+    content = await readFile3(conventionsPath, "utf-8");
   } catch {
     return false;
   }
   if (/^##\s+Skill\s+Authoring/im.test(content)) return false;
-  await writeFile2(conventionsPath, content.trimEnd() + "\n" + SKILL_AUTHORING_SECTION);
+  await writeFile3(conventionsPath, content.trimEnd() + "\n" + SKILL_AUTHORING_SECTION);
   log.success("Added Skill Authoring section to .claude/rules/conventions.md");
   return true;
 }
 async function createEnhanceSkill(root) {
-  const skillDir = join4(root, ".claude", "skills", "lp-enhance");
-  const skillPath = join4(skillDir, "SKILL.md");
-  const globalPath = join4(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
-  const legacyProject = join4(root, ".claude", "commands", "lp-enhance.md");
-  const legacyGlobal = join4(homedir(), ".claude", "commands", "lp-enhance.md");
+  const skillDir = join5(root, ".claude", "skills", "lp-enhance");
+  const skillPath = join5(skillDir, "SKILL.md");
+  const globalPath = join5(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join5(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join5(homedir(), ".claude", "commands", "lp-enhance.md");
   if (await fileExists(skillPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return false;
   await mkdir2(skillDir, { recursive: true });
-  await writeFile2(skillPath, generateEnhanceSkill());
+  await writeFile3(skillPath, generateEnhanceSkill());
   log.success("Generated /lp-enhance skill (.claude/skills/lp-enhance/)");
   return true;
 }
 async function updateEnhanceSkill(root) {
-  const projectPath = join4(root, ".claude", "skills", "lp-enhance", "SKILL.md");
-  const globalPath = join4(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const projectPath = join5(root, ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join5(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
   const targetPath = await fileExists(projectPath) ? projectPath : await fileExists(globalPath) ? globalPath : null;
   if (!targetPath) return false;
-  await writeFile2(targetPath, generateEnhanceSkill());
+  await writeFile3(targetPath, generateEnhanceSkill());
   log.success("Updated /lp-enhance skill to latest version");
   return true;
 }
@@ -1140,10 +1267,16 @@ var colors = {
     return map[sev](` ${sev.toUpperCase()} `);
   }
 };
+var warnedKeys = /* @__PURE__ */ new Set();
 var log = {
   success: (msg) => console.log(`  ${chalk.green("\u2713")} ${msg}`),
   error: (msg) => console.log(`  ${chalk.red("\u2717")} ${msg}`),
   warn: (msg) => console.log(`  ${chalk.yellow("!")} ${msg}`),
+  warnOnce: (key, msg) => {
+    if (warnedKeys.has(key)) return;
+    warnedKeys.add(key);
+    console.log(`  ${chalk.yellow("!")} ${msg}`);
+  },
   step: (msg) => console.log(`  ${chalk.cyan("\u2192")} ${msg}`),
   info: (msg) => console.log(`  ${chalk.dim("\xB7")} ${msg}`),
   blank: () => console.log()
@@ -1212,6 +1345,41 @@ function renderDoctorReport(results, options) {
   return { overallScore, actionableCount: actionable.length };
 }
 
+// src/lib/settings.ts
+async function readJsonFile(path) {
+  let raw;
+  try {
+    raw = await readFile4(path, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return {};
+    log.warnOnce(`read:${path}`, `Could not read ${path}: ${err.message}`);
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    log.warnOnce(`parse:${path}`, `${path} is not valid JSON: ${err.message}. Treating as unreadable to avoid clobbering it.`);
+    return null;
+  }
+}
+async function readSettingsJson(root) {
+  return readJsonFile(join6(root, ".claude", "settings.json"));
+}
+async function writeSettingsJson(root, settings) {
+  const dir = join6(root, ".claude");
+  await mkdir3(dir, { recursive: true });
+  await writeFile4(join6(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+async function readSettingsLocalJson(root) {
+  return readJsonFile(join6(root, ".claude", "settings.local.json"));
+}
+async function writeSettingsLocalJson(root, settings) {
+  const dir = join6(root, ".claude");
+  await mkdir3(dir, { recursive: true });
+  await writeFile4(join6(dir, "settings.local.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+
 export {
   __export,
   SESSION_START_CONTENT,
@@ -1231,10 +1399,12 @@ export {
   writeSettingsLocalJson,
   getMemoryPlacement,
   LP_STUB_OPEN,
+  addOrUpdateHook,
+  writeSprintHygieneScripts,
   applyFixes,
   log,
   printBanner,
   printScoreCard,
   renderDoctorReport
 };
-//# sourceMappingURL=chunk-7QPZN27I.js.map
+//# sourceMappingURL=chunk-RCYLZUU6.js.map