claude-cli-advanced-starter-pack 1.0.16 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-cli-advanced-starter-pack",
-  "version": "1.0.16",
+  "version": "1.1.0",
   "description": "Advanced Claude Code CLI toolkit - agents, hooks, skills, MCP servers, phased development, and GitHub integration",
   "main": "src/index.js",
   "bin": {

package/src/commands/init.js

@@ -42,7 +42,7 @@ const OPTIONAL_FEATURES = [
     label: 'Token Budget Management',
     description: 'Monitor and manage Claude API token usage with automatic compaction warnings, archive suggestions, and respawn thresholds. Includes hooks that track usage per session.',
     commands: ['context-audit'],
-    hooks: ['context-guardian'],  // Only include hooks with templates
+    hooks: ['context-guardian', 'token-budget-loader', 'tool-output-cacher'],
     default: false,
     requiresPostConfig: false,
   },
@@ -51,10 +51,10 @@ const OPTIONAL_FEATURES = [
     label: 'Happy Engineering Integration',
     description: 'Integration with Happy Coder mobile app for remote session control, checkpoint management, and mobile-optimized responses.',
     commands: ['happy-start'],
-    hooks: ['happy-checkpoint-manager'],  // Only include hooks with templates
+    hooks: ['happy-checkpoint-manager', 'happy-title-generator', 'happy-mode-detector', 'context-injector'],
     default: false,
     requiresPostConfig: true,
-    npmPackage: 'happy-coder',  // Optional npm package to install
+    npmPackage: 'happy-coder',
     npmInstallPrompt: 'Install Happy Coder CLI globally? (npm i -g happy-coder)',
   },
   {

package/src/data/releases.json

@@ -1,5 +1,50 @@
 {
   "releases": [
+    {
+      "version": "1.1.0",
+      "date": "2026-01-30",
+      "summary": "Feature: Phase 1 of 85 Recommendations - 5 New Hook Templates",
+      "highlights": [
+        "Added tool-output-cacher.template.js - Caches large outputs, saves ~500 tokens per output",
+        "Added token-budget-loader.template.js - Pre-calculates daily budget, ~5K tokens/session savings",
+        "Added happy-title-generator.template.js - Auto-generates session titles with issue numbers",
+        "Added happy-mode-detector.template.js - Detects Happy daemon environment",
+        "Added context-injector.template.js - Injects prior session context for continuity",
+        "All hooks now configurable via .claude/config/hooks-config.json",
+        "Updated tokenManagement feature to include token-budget-loader and tool-output-cacher",
+        "Updated happyMode feature to include all Happy-related hooks"
+      ],
+      "newFeatures": {
+        "commands": [],
+        "agents": [],
+        "skills": [],
+        "hooks": [
+          {
+            "name": "tool-output-cacher",
+            "description": "Caches large tool outputs to reduce context consumption"
+          },
+          {
+            "name": "token-budget-loader",
+            "description": "Pre-calculates daily token budget at session start"
+          },
+          {
+            "name": "happy-title-generator",
+            "description": "Auto-generates session titles for Happy daemon"
+          },
+          {
+            "name": "happy-mode-detector",
+            "description": "Detects Happy daemon environment and enables mobile mode"
+          },
+          {
+            "name": "context-injector",
+            "description": "Injects prior session context for seamless resumption"
+          }
+        ],
+        "other": []
+      },
+      "breaking": [],
+      "deprecated": []
+    },
     {
       "version": "1.0.16",
       "date": "2026-01-30",

package/templates/hooks/context-injector.template.js

@@ -0,0 +1,261 @@
+/**
+ * Context Injector Hook
+ *
+ * Injects prior session context for seamless resumption.
+ * Loads checkpoints, recent progress, and active features.
+ * Enables continuity across multi-day projects.
+ *
+ * Event: UserPromptSubmit (runs once per session)
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  recent_completed_tasks: 3,     // Number of completed tasks to show
+  next_pending_tasks: 2,         // Number of pending tasks to show
+  active_features_limit: 3,      // Number of active features to show
+  recent_agents_limit: 5,        // Number of recent agents to show
+  max_checkpoint_age_hours: 48,  // Ignore checkpoints older than this
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const CHECKPOINT_PATH = path.join(process.cwd(), '.claude', 'checkpoints', 'latest.json');
+const FEATURE_TRACKING_PATH = path.join(process.cwd(), '.claude', 'config', 'feature-tracking.json');
+const AGENT_LOG_PATH = path.join(process.cwd(), '.claude', 'logs', 'agent-activity.json');
+const SESSION_MARKER = path.join(process.cwd(), '.claude', 'config', '.context-injected');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.context_injector || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Check if we've already injected context this session
+ */
+function hasInjectedThisSession() {
+  try {
+    if (fs.existsSync(SESSION_MARKER)) {
+      const content = fs.readFileSync(SESSION_MARKER, 'utf8');
+      const timestamp = parseInt(content, 10);
+      // Session valid for 4 hours
+      if (Date.now() - timestamp < 4 * 60 * 60 * 1000) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Continue with injection
+  }
+  return false;
+}
+
+/**
+ * Mark session as injected
+ */
+function markSessionInjected() {
+  try {
+    const dir = path.dirname(SESSION_MARKER);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(SESSION_MARKER, Date.now().toString(), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Load latest checkpoint
+ */
+function loadCheckpoint(config) {
+  try {
+    if (!fs.existsSync(CHECKPOINT_PATH)) {
+      return null;
+    }
+
+    const checkpoint = JSON.parse(fs.readFileSync(CHECKPOINT_PATH, 'utf8'));
+
+    // Check age
+    if (checkpoint.created_at) {
+      const age = Date.now() - new Date(checkpoint.created_at).getTime();
+      const maxAge = config.max_checkpoint_age_hours * 60 * 60 * 1000;
+      if (age > maxAge) {
+        return null; // Checkpoint too old
+      }
+    }
+
+    return checkpoint;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Load feature tracking
+ */
+function loadFeatureTracking() {
+  try {
+    if (fs.existsSync(FEATURE_TRACKING_PATH)) {
+      return JSON.parse(fs.readFileSync(FEATURE_TRACKING_PATH, 'utf8'));
+    }
+  } catch (e) {
+    // No feature tracking
+  }
+  return null;
+}
+
+/**
+ * Load recent agent activity
+ */
+function loadAgentActivity(config) {
+  try {
+    if (fs.existsSync(AGENT_LOG_PATH)) {
+      const activity = JSON.parse(fs.readFileSync(AGENT_LOG_PATH, 'utf8'));
+      // Return most recent agents
+      if (Array.isArray(activity)) {
+        return activity.slice(-config.recent_agents_limit);
+      }
+    }
+  } catch (e) {
+    // No agent activity
+  }
+  return [];
+}
+
+/**
+ * Format task list for display
+ */
+function formatTaskList(tasks, limit, status) {
+  if (!tasks || !Array.isArray(tasks)) return '';
+
+  const filtered = tasks.filter(t => t.status === status).slice(0, limit);
+  if (filtered.length === 0) return '';
+
+  return filtered.map(t => `  - ${t.title || t.name || 'Unknown task'}`).join('\n');
+}
+
+/**
+ * Format feature list for display
+ */
+function formatFeatureList(features, limit) {
+  if (!features || !Array.isArray(features)) return '';
+
+  const active = features.filter(f => f.status === 'in_progress').slice(0, limit);
+  if (active.length === 0) return '';
+
+  return active.map(f => `  - ${f.name}: ${f.progress || 0}%`).join('\n');
+}
+
+/**
+ * Format agent list for display
+ */
+function formatAgentList(agents) {
+  if (!agents || agents.length === 0) return '';
+
+  return agents.map(a => {
+    const name = a.name || a.type || 'agent';
+    const status = a.success ? 'completed' : 'failed';
+    return `  - ${name}: ${status}`;
+  }).join('\n');
+}
+
+/**
+ * Build context message
+ */
+function buildContextMessage(checkpoint, features, agents, config) {
+  const sections = [];
+
+  // Add checkpoint progress
+  if (checkpoint) {
+    const completed = formatTaskList(checkpoint.tasks, config.recent_completed_tasks, 'completed');
+    const pending = formatTaskList(checkpoint.tasks, config.next_pending_tasks, 'pending');
+
+    if (completed) {
+      sections.push(`**Recent Progress:**\n${completed}`);
+    }
+    if (pending) {
+      sections.push(`**Next Tasks:**\n${pending}`);
+    }
+    if (checkpoint.current_phase) {
+      sections.push(`**Current Phase:** ${checkpoint.current_phase}`);
+    }
+  }
+
+  // Add active features
+  if (features) {
+    const featureList = formatFeatureList(features.features || features, config.active_features_limit);
+    if (featureList) {
+      sections.push(`**Active Features:**\n${featureList}`);
+    }
+  }
+
+  // Add recent agents
+  if (agents && agents.length > 0) {
+    const agentList = formatAgentList(agents);
+    if (agentList) {
+      sections.push(`**Recent Agents:**\n${agentList}`);
+    }
+  }
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function contextInjector(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    // Check if already injected this session
+    if (hasInjectedThisSession()) {
+      return approve();
+    }
+
+    // Mark session as injected
+    markSessionInjected();
+
+    const config = loadConfig();
+
+    // Load context sources
+    const checkpoint = loadCheckpoint(config);
+    const features = loadFeatureTracking();
+    const agents = loadAgentActivity(config);
+
+    // Check if we have any context to inject
+    if (!checkpoint && !features && agents.length === 0) {
+      console.log('[context-injector] No prior context found');
+      return approve();
+    }
+
+    // Build context message
+    const message = buildContextMessage(checkpoint, features, agents, config);
+
+    if (message) {
+      console.log('[context-injector] Session context loaded:');
+      console.log('---');
+      console.log(message);
+      console.log('---');
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[context-injector] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/happy-mode-detector.template.js

@@ -0,0 +1,214 @@
+/**
+ * Happy Mode Detector Hook
+ *
+ * Auto-detects Happy daemon environment and enables mobile-optimized mode.
+ * Sets appropriate verbosity and response formatting for mobile clients.
+ * Supports multiple detection methods: env var, daemon state, manual config.
+ *
+ * Event: UserPromptSubmit (runs once per session)
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  enabled: false,                     // Manual override
+  auto_detect: true,                  // Attempt auto-detection
+  verbosity: 'condensed',             // 'verbose', 'condensed', 'compact'
+  show_file_stats: true,              // Show file operation statistics
+  max_grep_results: 5,                // Limit grep results for mobile
+  checkpoint_interval_minutes: 10,    // Auto-checkpoint frequency
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const HAPPY_MODE_PATH = path.join(process.cwd(), '.claude', 'config', 'happy-mode.json');
+const HAPPY_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE, '.happy', 'daemon.state.json');
+const SESSION_MARKER = path.join(process.cwd(), '.claude', 'config', '.happy-detected');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.happy_mode || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Check if we've already detected Happy mode this session
+ */
+function hasDetectedThisSession() {
+  try {
+    if (fs.existsSync(SESSION_MARKER)) {
+      const content = fs.readFileSync(SESSION_MARKER, 'utf8');
+      const data = JSON.parse(content);
+      // Session valid for 4 hours
+      if (Date.now() - data.timestamp < 4 * 60 * 60 * 1000) {
+        return data;
+      }
+    }
+  } catch (e) {
+    // Continue with detection
+  }
+  return null;
+}
+
+/**
+ * Mark session as detected
+ */
+function markSessionDetected(result) {
+  try {
+    const dir = path.dirname(SESSION_MARKER);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(SESSION_MARKER, JSON.stringify({
+      timestamp: Date.now(),
+      ...result,
+    }, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Detect Happy mode via environment variable
+ */
+function detectViaEnvVar() {
+  return process.env.HAPPY_SESSION === 'true';
+}
+
+/**
+ * Detect Happy mode via daemon state file
+ */
+function detectViaDaemonState() {
+  try {
+    if (fs.existsSync(HAPPY_STATE_PATH)) {
+      const state = JSON.parse(fs.readFileSync(HAPPY_STATE_PATH, 'utf8'));
+      // Check if daemon is running and has active session
+      if (state.running && state.current_session) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Daemon not running or state invalid
+  }
+  return false;
+}
+
+/**
+ * Detect Happy mode via manual configuration
+ */
+function detectViaManualConfig() {
+  try {
+    if (fs.existsSync(HAPPY_MODE_PATH)) {
+      const config = JSON.parse(fs.readFileSync(HAPPY_MODE_PATH, 'utf8'));
+      return config.enabled === true;
+    }
+  } catch (e) {
+    // No manual config
+  }
+  return false;
+}
+
+/**
+ * Get detection method description
+ */
+function getDetectionMethod(envVar, daemon, manual) {
+  if (manual) return 'manual_config';
+  if (envVar) return 'env_var';
+  if (daemon) return 'daemon_state';
+  return 'none';
+}
+
+/**
+ * Save Happy mode state for other hooks to use
+ */
+function saveHappyModeState(result) {
+  try {
+    const dir = path.dirname(HAPPY_MODE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(HAPPY_MODE_PATH, JSON.stringify(result, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function happyModeDetector(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    // Check if already detected this session
+    const cached = hasDetectedThisSession();
+    if (cached) {
+      return approve();
+    }
+
+    const config = loadConfig();
+
+    // Skip detection if auto-detect is disabled
+    if (!config.auto_detect) {
+      const result = {
+        happy_mode: config.enabled,
+        detection_method: config.enabled ? 'manual_override' : 'disabled',
+        config: config,
+      };
+      markSessionDetected(result);
+      return approve();
+    }
+
+    // Try all detection methods
+    const viaEnvVar = detectViaEnvVar();
+    const viaDaemon = detectViaDaemonState();
+    const viaManual = detectViaManualConfig();
+
+    const isHappyMode = viaEnvVar || viaDaemon || viaManual;
+    const detectionMethod = getDetectionMethod(viaEnvVar, viaDaemon, viaManual);
+
+    // Build result object
+    const result = {
+      happy_mode: isHappyMode,
+      detection_method: detectionMethod,
+      detected_at: new Date().toISOString(),
+      config: {
+        verbosity: config.verbosity,
+        show_file_stats: config.show_file_stats,
+        max_grep_results: config.max_grep_results,
+        checkpoint_interval_minutes: config.checkpoint_interval_minutes,
+      },
+    };
+
+    // Save state for other hooks
+    saveHappyModeState(result);
+    markSessionDetected(result);
+
+    // Log detection result
+    if (isHappyMode) {
+      console.log(`[happy-mode-detector] Happy mode ENABLED (via ${detectionMethod})`);
+      console.log(`[happy-mode-detector] Verbosity: ${config.verbosity}`);
+    } else {
+      console.log('[happy-mode-detector] Happy mode not detected');
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[happy-mode-detector] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/happy-title-generator.template.js

@@ -0,0 +1,260 @@
+/**
+ * Happy Title Generator Hook
+ *
+ * Auto-generates session titles with format: "Issue #XX - Summary"
+ * Detects GitHub issue numbers from branch names.
+ * Notifies Happy daemon of title updates for mobile display.
+ *
+ * Event: UserPromptSubmit
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  rate_limit_ms: 30000,           // Throttle title updates to once per 30 sec
+  max_summary_words: 4,           // Maximum words in title summary
+  issue_pattern: 'issue-(\\d+)',  // Regex to extract issue number from branch
+  common_prefixes: [              // Prefixes to remove from summaries
+    'implement', 'add', 'fix', 'update', 'create',
+    'refactor', 'build', 'remove', 'optimize', 'improve'
+  ],
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const STATE_PATH = path.join(process.cwd(), '.claude', 'config', 'title-generator-state.json');
+const HAPPY_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE, '.happy', 'daemon.state.json');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.title_generator || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Load state
+ */
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_PATH)) {
+      return JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+    }
+  } catch (e) {
+    // Return fresh state
+  }
+  return {
+    last_update: 0,
+    current_title: null,
+    issue_number: null,
+  };
+}
+
+/**
+ * Save state
+ */
+function saveState(state) {
+  try {
+    const dir = path.dirname(STATE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+    return branch;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Extract issue number from branch name
+ */
+function extractIssueNumber(branch, config) {
+  if (!branch) return null;
+
+  try {
+    const pattern = new RegExp(config.issue_pattern, 'i');
+    const match = branch.match(pattern);
+    if (match && match[1]) {
+      return parseInt(match[1], 10);
+    }
+  } catch (e) {
+    // Invalid regex pattern
+  }
+
+  // Try common patterns as fallback
+  const fallbackPatterns = [
+    /issue-(\d+)/i,
+    /(\d+)-/,
+    /#(\d+)/,
+  ];
+
+  for (const pattern of fallbackPatterns) {
+    const match = branch.match(pattern);
+    if (match && match[1]) {
+      return parseInt(match[1], 10);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Generate summary from user prompt
+ */
+function generateSummary(prompt, config) {
+  if (!prompt) return 'New Session';
+
+  // Clean the prompt
+  let summary = prompt.trim();
+
+  // Remove common prefixes
+  const prefixPattern = new RegExp(`^(${config.common_prefixes.join('|')})\\s+`, 'i');
+  summary = summary.replace(prefixPattern, '');
+
+  // Take first N words
+  const words = summary.split(/\s+/).slice(0, config.max_summary_words);
+  summary = words.join(' ');
+
+  // Capitalize first letter
+  if (summary.length > 0) {
+    summary = summary.charAt(0).toUpperCase() + summary.slice(1);
+  }
+
+  // Truncate if too long
+  if (summary.length > 50) {
+    summary = summary.substring(0, 47) + '...';
+  }
+
+  return summary || 'New Session';
+}
+
+/**
+ * Format title with issue number
+ */
+function formatTitle(issueNumber, summary, branch) {
+  let title = '';
+
+  if (issueNumber) {
+    title = `Issue #${issueNumber} - ${summary}`;
+  } else {
+    title = summary;
+  }
+
+  // Add branch info if available
+  if (branch && branch !== 'main' && branch !== 'master') {
+    const shortBranch = branch.length > 20 ? branch.substring(0, 17) + '...' : branch;
+    title = `${title} | ${shortBranch}`;
+  }
+
+  return title;
+}
+
+/**
+ * Notify Happy daemon of title update
+ */
+function notifyHappyDaemon(title) {
+  try {
+    if (!fs.existsSync(HAPPY_STATE_PATH)) {
+      return false; // Happy daemon not running
+    }
+
+    const happyState = JSON.parse(fs.readFileSync(HAPPY_STATE_PATH, 'utf8'));
+
+    // Update session title in daemon state
+    happyState.current_session = happyState.current_session || {};
+    happyState.current_session.title = title;
+    happyState.current_session.updated_at = new Date().toISOString();
+
+    // Write atomically using temp file
+    const tempPath = HAPPY_STATE_PATH + '.tmp';
+    fs.writeFileSync(tempPath, JSON.stringify(happyState, null, 2), 'utf8');
+    fs.renameSync(tempPath, HAPPY_STATE_PATH);
+
+    return true;
+  } catch (e) {
+    return false; // Silent failure - daemon may not be running
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function happyTitleGenerator(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    const config = loadConfig();
+    const state = loadState();
+    const now = Date.now();
+
+    // Rate limiting - don't update too frequently
+    if (state.last_update && (now - state.last_update) < config.rate_limit_ms) {
+      return approve();
+    }
+
+    // Parse hook input for user prompt
+    let userPrompt = '';
+    try {
+      const input = JSON.parse(process.env.CLAUDE_HOOK_INPUT || '{}');
+      userPrompt = input.prompt || input.message || '';
+    } catch (e) {
+      // No prompt available
+    }
+
+    // Get git context
+    const branch = getCurrentBranch();
+    const issueNumber = extractIssueNumber(branch, config);
+
+    // Generate title components
+    const summary = generateSummary(userPrompt, config);
+    const title = formatTitle(issueNumber, summary, branch);
+
+    // Update state
+    state.last_update = now;
+    state.current_title = title;
+    state.issue_number = issueNumber;
+    saveState(state);
+
+    // Notify Happy daemon (if running)
+    const notified = notifyHappyDaemon(title);
+
+    if (notified) {
+      console.log(`[happy-title-generator] Title updated: ${title}`);
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[happy-title-generator] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/token-budget-loader.template.js

@@ -0,0 +1,234 @@
+/**
+ * Token Budget Loader Hook
+ *
+ * Pre-calculates daily token budget at session start.
+ * Tracks usage across sessions and provides health status alerts.
+ * Saves ~5K tokens/session by pre-loading budget state.
+ *
+ * Event: UserPromptSubmit (runs once per session)
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  daily_limit: 200000,        // Daily token budget
+  warning_percent: 60,        // Warn at this percentage
+  critical_percent: 80,       // Critical warning at this percentage
+  reset_hours: 24,            // Budget reset cycle in hours
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const BUDGET_PATH = path.join(process.cwd(), '.claude', 'config', 'token-budget.json');
+const SESSION_MARKER = path.join(process.cwd(), '.claude', 'config', '.budget-loaded');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.token_budget || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Load budget state
+ */
+function loadBudget() {
+  try {
+    if (fs.existsSync(BUDGET_PATH)) {
+      return JSON.parse(fs.readFileSync(BUDGET_PATH, 'utf8'));
+    }
+  } catch (e) {
+    // Return fresh budget
+  }
+  return null;
+}
+
+/**
+ * Save budget state
+ */
+function saveBudget(budget) {
+  try {
+    const dir = path.dirname(BUDGET_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(BUDGET_PATH, JSON.stringify(budget, null, 2), 'utf8');
+  } catch (e) {
+    console.error(`[token-budget-loader] Failed to save budget: ${e.message}`);
+  }
+}
+
+/**
+ * Check if we've already loaded budget this session
+ */
+function hasLoadedThisSession() {
+  try {
+    if (fs.existsSync(SESSION_MARKER)) {
+      const content = fs.readFileSync(SESSION_MARKER, 'utf8');
+      const timestamp = parseInt(content, 10);
+      // Session valid for 4 hours
+      if (Date.now() - timestamp < 4 * 60 * 60 * 1000) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Continue with loading
+  }
+  return false;
+}
+
+/**
+ * Mark session as loaded
+ */
+function markSessionLoaded() {
+  try {
+    const dir = path.dirname(SESSION_MARKER);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(SESSION_MARKER, Date.now().toString(), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Check if budget should reset (new day)
+ */
+function shouldResetBudget(budget, config) {
+  if (!budget || !budget.reset_at) {
+    return true;
+  }
+
+  const resetAt = new Date(budget.reset_at);
+  const now = new Date();
+
+  return now >= resetAt;
+}
+
+/**
+ * Calculate next reset time
+ */
+function getNextResetTime(config) {
+  const now = new Date();
+  const resetTime = new Date(now);
+
+  // Reset at midnight UTC by default
+  resetTime.setUTCHours(0, 0, 0, 0);
+  resetTime.setTime(resetTime.getTime() + config.reset_hours * 60 * 60 * 1000);
+
+  // If we've passed today's reset, move to next cycle
+  while (resetTime <= now) {
+    resetTime.setTime(resetTime.getTime() + config.reset_hours * 60 * 60 * 1000);
+  }
+
+  return resetTime.toISOString();
+}
+
+/**
+ * Estimate tokens from characters (rough approximation)
+ * Claude uses ~4 chars per token on average
+ */
+function estimateTokens(chars) {
+  return Math.ceil(chars / 4);
+}
+
+/**
+ * Get budget health status
+ */
+function getBudgetHealth(budget, config) {
+  const percentUsed = (budget.used / budget.limit) * 100;
+
+  if (percentUsed >= config.critical_percent) {
+    return {
+      status: 'critical',
+      message: `CRITICAL: ${percentUsed.toFixed(1)}% of daily budget used`,
+      color: 'red',
+    };
+  } else if (percentUsed >= config.warning_percent) {
+    return {
+      status: 'warning',
+      message: `WARNING: ${percentUsed.toFixed(1)}% of daily budget used`,
+      color: 'yellow',
+    };
+  } else {
+    return {
+      status: 'healthy',
+      message: `Budget healthy: ${percentUsed.toFixed(1)}% used`,
+      color: 'green',
+    };
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function tokenBudgetLoader(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    // Only run once per session
+    if (hasLoadedThisSession()) {
+      return approve();
+    }
+
+    // Mark this session as loaded
+    markSessionLoaded();
+
+    const config = loadConfig();
+    let budget = loadBudget();
+
+    // Check if we need to reset the budget
+    if (shouldResetBudget(budget, config)) {
+      budget = {
+        limit: config.daily_limit,
+        used: 0,
+        reset_at: getNextResetTime(config),
+        sessions: [],
+        created_at: new Date().toISOString(),
+      };
+      saveBudget(budget);
+      console.log(`[token-budget-loader] Budget reset. Daily limit: ${config.daily_limit.toLocaleString()} tokens`);
+    }
+
+    // Calculate remaining budget
+    const remaining = budget.limit - budget.used;
+    const health = getBudgetHealth(budget, config);
+
+    // Log budget status
+    console.log(`[token-budget-loader] ${health.message}`);
+    console.log(`[token-budget-loader] Remaining: ${remaining.toLocaleString()} tokens`);
+    console.log(`[token-budget-loader] Resets at: ${budget.reset_at}`);
+
+    // Record this session start
+    budget.sessions.push({
+      started_at: new Date().toISOString(),
+      initial_remaining: remaining,
+    });
+
+    // Keep only last 10 sessions
+    if (budget.sessions.length > 10) {
+      budget.sessions = budget.sessions.slice(-10);
+    }
+
+    saveBudget(budget);
+
+    return approve();
+  } catch (error) {
+    console.error(`[token-budget-loader] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/tool-output-cacher.template.js

@@ -0,0 +1,219 @@
+/**
+ * Tool Output Cacher Hook
+ *
+ * Caches large tool outputs (>2KB) to reduce context consumption.
+ * Monitors cumulative session output and warns at thresholds.
+ * Saves ~500 tokens per large output by storing in cache files.
+ *
+ * Event: PostToolUse
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  threshold_chars: 2048,           // Cache outputs larger than this
+  warning_threshold: 100000,       // Warn when session total exceeds this
+  critical_threshold: 150000,      // Critical warning at this level
+  session_timeout_ms: 300000,      // 5 minutes - consider new session
+  cacheable_tools: ['Bash', 'Read', 'Glob', 'Grep'],
+  bypass_tools: ['Task', 'TaskOutput'],
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const CACHE_DIR = path.join(process.cwd(), '.claude', 'cache', 'tool-outputs');
+const STATE_FILE = path.join(process.cwd(), '.claude', 'config', 'tool-output-cacher-state.json');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.output_caching || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Load session state
+ */
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    }
+  } catch (e) {
+    // Return fresh state
+  }
+  return {
+    session_id: null,
+    session_start: null,
+    cumulative_chars: 0,
+    cached_count: 0,
+    last_activity: null,
+  };
+}
+
+/**
+ * Save session state
+ */
+function saveState(state) {
+  try {
+    const dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure - don't block tool execution
+  }
+}
+
+/**
+ * Generate cache key for output
+ */
+function generateCacheKey(toolName, output) {
+  const hash = crypto.createHash('md5').update(output.slice(0, 500)).digest('hex').slice(0, 8);
+  return `${toolName.toLowerCase()}-${Date.now()}-${hash}`;
+}
+
+/**
+ * Cache output to file
+ */
+function cacheOutput(key, output, summary) {
+  try {
+    if (!fs.existsSync(CACHE_DIR)) {
+      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+
+    const cachePath = path.join(CACHE_DIR, `${key}.txt`);
+    fs.writeFileSync(cachePath, output, 'utf8');
+
+    return {
+      cached: true,
+      path: cachePath,
+      summary: summary,
+    };
+  } catch (e) {
+    return { cached: false, error: e.message };
+  }
+}
+
+/**
+ * Generate summary of large output
+ */
+function generateSummary(output, maxLines = 15) {
+  const lines = output.split('\n');
+  const totalLines = lines.length;
+  const totalChars = output.length;
+
+  // Take first N lines as preview
+  const preview = lines.slice(0, maxLines).join('\n');
+
+  return {
+    preview: preview,
+    total_lines: totalLines,
+    total_chars: totalChars,
+    truncated: totalLines > maxLines,
+  };
+}
+
+/**
+ * Check if tool output should be cached
+ */
+function shouldCache(toolName, output, config) {
+  // Skip bypass tools
+  if (config.bypass_tools.includes(toolName)) {
+    return false;
+  }
+
+  // Check if tool is cacheable
+  const isCacheable = config.cacheable_tools.some(t =>
+    toolName.startsWith(t) || toolName === t
+  );
+
+  if (!isCacheable) {
+    return false;
+  }
+
+  // Check size threshold
+  return output.length > config.threshold_chars;
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function toolOutputCacher(context) {
+  // Always approve - this is a PostToolUse hook for monitoring only
+  const approve = () => ({ continue: true });
+
+  try {
+    // Parse hook input
+    const input = JSON.parse(process.env.CLAUDE_HOOK_INPUT || '{}');
+    const { tool_name, tool_input, tool_output } = input;
+
+    if (!tool_name || !tool_output) {
+      return approve();
+    }
+
+    const output = typeof tool_output === 'string' ? tool_output : JSON.stringify(tool_output);
+    const config = loadConfig();
+
+    // Load and update session state
+    let state = loadState();
+    const now = Date.now();
+
+    // Check if this is a new session
+    if (!state.session_start || (now - state.last_activity) > config.session_timeout_ms) {
+      state = {
+        session_id: crypto.randomBytes(4).toString('hex'),
+        session_start: now,
+        cumulative_chars: 0,
+        cached_count: 0,
+        last_activity: now,
+      };
+    }
+
+    // Update cumulative tracking
+    state.cumulative_chars += output.length;
+    state.last_activity = now;
+
+    // Check if we should cache this output
+    if (shouldCache(tool_name, output, config)) {
+      const summary = generateSummary(output);
+      const cacheKey = generateCacheKey(tool_name, output);
+      const cacheResult = cacheOutput(cacheKey, output, summary);
+
+      if (cacheResult.cached) {
+        state.cached_count++;
+        console.log(`[tool-output-cacher] Cached ${tool_name} output (${output.length} chars) -> ${cacheResult.path}`);
+      }
+    }
+
+    // Check thresholds and warn
+    if (state.cumulative_chars >= config.critical_threshold) {
+      console.log(`[tool-output-cacher] CRITICAL: Session at ${state.cumulative_chars} chars. Consider compaction.`);
+    } else if (state.cumulative_chars >= config.warning_threshold) {
+      console.log(`[tool-output-cacher] WARNING: Session at ${state.cumulative_chars} chars.`);
+    }
+
+    // Save state
+    saveState(state);
+
+    return approve();
+  } catch (error) {
+    // Always approve even on error
+    console.error(`[tool-output-cacher] Error: ${error.message}`);
+    return approve();
+  }
+};