@haposoft/cafekit 0.3.11 → 0.4.0

package/src/claude/hooks/lib/git.cjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Git Info Cache - Cross-platform git information batching
+ *
+ * Problem: 5-6 git process spawns per statusline render are slow on Windows (CreateProcess overhead)
+ * Solution: Cache git query results for 3 seconds — subsequent renders read cache (zero processes)
+ *
+ * Performance: 5 spawns per render → event-driven refresh + 30s TTL fallback
+ * Cross-platform: No bash-only syntax (no 2>/dev/null), windowsHide on all exec calls
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Cache TTL — long fallback for external changes (git checkout outside Claude)
+// Active invalidation happens via PostToolUse hooks after Edit/Write/Bash
+const CACHE_TTL = 30000;
+const CACHE_MISS = Symbol('cache_miss');
+
+/**
+ * Safe command execution wrapper with optional cwd
+ */
+function execIn(cmd, cwd) {
+  try {
+    return execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      windowsHide: true,
+      cwd: cwd || undefined
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Get cache file path for current working directory
+ */
+function getCachePath(cwd) {
+  const hash = require('crypto')
+    .createHash('md5')
+    .update(cwd)
+    .digest('hex')
+    .slice(0, 8);
+  return path.join(os.tmpdir(), `ck-git-cache-${hash}.json`);
+}
+
+/**
+ * Read cache if valid (not expired). Returns CACHE_MISS on miss.
+ * No existsSync check (TOCTOU race) — just try read and catch.
+ */
+function readCache(cachePath) {
+  try {
+    const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+    if (Date.now() - cache.timestamp < CACHE_TTL) {
+      return cache.data; // Can be null (non-git dir) or object (git info)
+    }
+  } catch {
+    // File missing, corrupted, or expired — all treated as cache miss
+  }
+  return CACHE_MISS;
+}
+
+/**
+ * Write cache atomically (temp file + rename to avoid partial reads on Windows)
+ */
+function writeCache(cachePath, data) {
+  const tmpPath = cachePath + '.tmp';
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify({ timestamp: Date.now(), data }));
+    fs.renameSync(tmpPath, cachePath);
+  } catch {
+    try { fs.unlinkSync(tmpPath); } catch {}
+  }
+}
+
+/**
+ * Count non-empty lines in a newline-delimited string
+ */
+function countLines(str) {
+  if (!str) return 0;
+  return str.split('\n').filter(l => l.trim()).length;
+}
+
+/**
+ * Fetch git info directly in-process
+ * The cache is what eliminates redundant spawns — not subprocess wrapping
+ * @param {string} cwd - Directory to run git commands in
+ * Returns: { branch, unstaged, staged, ahead, behind } or null if not git repo
+ */
+function fetchGitInfo(cwd) {
+  // Check if git repo (fast check) — run in target cwd, not process.cwd()
+  if (!execIn('git rev-parse --git-dir', cwd)) {
+    return null;
+  }
+
+  const branch = execIn('git branch --show-current', cwd) || execIn('git rev-parse --short HEAD', cwd);
+  const unstaged = countLines(execIn('git diff --name-only', cwd));
+  const staged = countLines(execIn('git diff --cached --name-only', cwd));
+
+  // Ahead/behind — no 2>/dev/null (invalid on Windows cmd.exe)
+  let ahead = 0, behind = 0;
+  const aheadBehind = execIn('git rev-list --left-right --count @{u}...HEAD', cwd);
+  if (aheadBehind) {
+    const parts = aheadBehind.split(/\s+/);
+    behind = parseInt(parts[0], 10) || 0;
+    ahead = parseInt(parts[1], 10) || 0;
+  }
+
+  return { branch, unstaged, staged, ahead, behind };
+}
+
+/**
+ * Get git info with caching
+ * Main export function used by statusline
+ */
+function getGitInfo(cwd = process.cwd()) {
+  const cachePath = getCachePath(cwd);
+
+  // Try cache first (includes cached null for non-git dirs)
+  const cached = readCache(cachePath);
+  if (cached !== CACHE_MISS) return cached;
+
+  // Cache miss or expired, fetch fresh data in target cwd
+  const data = fetchGitInfo(cwd);
+  // Cache both positive and null results (avoids re-spawning git in non-git dirs)
+  writeCache(cachePath, data);
+
+  return data;
+}
+
+/**
+ * Invalidate cache for a directory (call after file changes to trigger fresh git query)
+ */
+function invalidateCache(cwd = process.cwd()) {
+  try { fs.unlinkSync(getCachePath(cwd)); } catch {}
+}
+
+module.exports = { getGitInfo, invalidateCache };

package/src/claude/hooks/lib/parser.cjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Transcript Parser - Extract tool/agent/todo state from session JSONL
+ * @module transcript-parser
+ */
+
+const fs = require('fs');
+const readline = require('readline');
+
+/**
+ * Parse transcript JSONL file
+ * @param {string} transcriptPath - Path to transcript file
+ * @returns {Promise<TranscriptData>}
+ */
+async function parseTranscript(transcriptPath) {
+  const result = {
+    tools: [],
+    agents: [],
+    todos: [],
+    sessionStart: null
+  };
+
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    return result;
+  }
+
+  const toolMap = new Map();
+  const agentMap = new Map();
+  let latestTodos = [];
+
+  try {
+    const fileStream = fs.createReadStream(transcriptPath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry = JSON.parse(line);
+        processEntry(entry, toolMap, agentMap, latestTodos, result);
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  } catch {
+    // Return partial results on error
+  }
+
+  result.tools = Array.from(toolMap.values()).slice(-20);
+  result.agents = Array.from(agentMap.values()).slice(-10);
+  result.todos = latestTodos;
+
+  return result;
+}
+
+/**
+ * Process single JSONL entry
+ * @param {Object} entry - Parsed JSON line
+ * @param {Map} toolMap - Tool tracking map
+ * @param {Map} agentMap - Agent tracking map
+ * @param {Array} latestTodos - Latest todo array reference
+ * @param {Object} result - Result object
+ */
+function processEntry(entry, toolMap, agentMap, latestTodos, result) {
+  const timestamp = entry.timestamp ? new Date(entry.timestamp) : new Date();
+
+  // Track session start
+  if (!result.sessionStart && entry.timestamp) {
+    result.sessionStart = timestamp;
+  }
+
+  const content = entry.message?.content;
+  if (!content || !Array.isArray(content)) return;
+
+  for (const block of content) {
+    // Handle tool_use blocks
+    if (block.type === 'tool_use' && block.id && block.name) {
+      if (block.name === 'Task') {
+        // Agent spawn
+        agentMap.set(block.id, {
+          id: block.id,
+          type: block.input?.subagent_type ?? 'unknown',
+          model: block.input?.model ?? null,
+          description: block.input?.description ?? null,
+          status: 'running',
+          startTime: timestamp,
+          endTime: null
+        });
+      } else if (block.name === 'TodoWrite') {
+        // Legacy: Replace todo array (deprecated, kept for backwards compatibility)
+        if (block.input?.todos && Array.isArray(block.input.todos)) {
+          latestTodos.length = 0;
+          latestTodos.push(...block.input.todos);
+        }
+      } else if (block.name === 'TaskCreate') {
+        // Native Task API: Add new task
+        if (block.input?.subject) {
+          latestTodos.push({
+            id: block.id,
+            content: block.input.subject,
+            status: 'pending',
+            activeForm: block.input.activeForm || null
+          });
+        }
+      } else if (block.name === 'TaskUpdate') {
+        // Native Task API: Update existing task status
+        if (block.input?.taskId && block.input?.status) {
+          const task = latestTodos.find(t => t.id === block.input.taskId);
+          if (task) {
+            task.status = block.input.status;
+          }
+        }
+      } else {
+        // Regular tool
+        toolMap.set(block.id, {
+          id: block.id,
+          name: block.name,
+          target: extractTarget(block.name, block.input),
+          status: 'running',
+          startTime: timestamp,
+          endTime: null
+        });
+      }
+    }
+
+    // Handle tool_result blocks
+    if (block.type === 'tool_result' && block.tool_use_id) {
+      const tool = toolMap.get(block.tool_use_id);
+      if (tool) {
+        tool.status = block.is_error ? 'error' : 'completed';
+        tool.endTime = timestamp;
+      }
+
+      const agent = agentMap.get(block.tool_use_id);
+      if (agent) {
+        agent.status = 'completed';
+        agent.endTime = timestamp;
+      }
+    }
+  }
+}
+
+/**
+ * Extract target from tool input
+ * @param {string} toolName - Tool name
+ * @param {Object} input - Tool input object
+ * @returns {string|null} - Extracted target
+ */
+function extractTarget(toolName, input) {
+  if (!input) return null;
+
+  switch (toolName) {
+    case 'Read':
+    case 'Write':
+    case 'Edit':
+      return input.file_path ?? input.path ?? null;
+
+    case 'Glob':
+    case 'Grep':
+      return input.pattern ?? null;
+
+    case 'Bash':
+      const cmd = input.command;
+      if (!cmd) return null;
+      return cmd.length > 30 ? cmd.slice(0, 30) + '...' : cmd;
+
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  parseTranscript,
+  // Export for testing
+  processEntry,
+  extractTarget
+};

package/src/claude/hooks/session.cjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+/**
+ * SessionStart Hook - Initializes session environment with project detection
+ *
+ * Fires: Once per session (startup, resume, clear, compact)
+ * Purpose: Load config, detect project info, persist to env vars, output context
+ *
+ * Exit Codes:
+ *   0 - Success (non-blocking, allows continuation)
+ *
+ * Core detection logic extracted to lib/detect.cjs for OpenCode plugin reuse.
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const {
+    loadConfig,
+    writeEnv,
+    writeSessionState,
+    resolvePlanPath,
+    getReportsPath,
+    resolveNamingPattern,
+    extractTaskListId,
+    isHookEnabled
+  } = require('./lib/config.cjs');
+
+  // Early exit if hook disabled in config
+  if (!isHookEnabled('session-init')) {
+    process.exit(0);
+  }
+
+  // Import shared project detection logic
+  const {
+    detectProjectType,
+    detectPackageManager,
+    detectFramework,
+    getPythonVersion,
+    getGitRemoteUrl,
+    getGitBranch,
+    getGitRoot,
+    getCodingLevelStyleName,
+    getCodingLevelGuidelines,
+    buildContextOutput,
+    execSafe
+  } = require('./lib/detect.cjs');
+
+/**
+ * One-time cleanup for orphaned .shadowed/ directories from skill-dedup hook (Issue #422)
+ * The hook was disabled due to race conditions; this restores any orphaned skills.
+ */
+function cleanupOrphanedShadowedSkills() {
+  const shadowedDir = path.join(process.cwd(), '.claude', 'skills', '.shadowed');
+  if (!fs.existsSync(shadowedDir)) return { restored: [], skipped: [], kept: [] };
+
+  const skillsDir = path.join(process.cwd(), '.claude', 'skills');
+  const restored = [];
+  const skipped = [];
+  const kept = []; // Skills kept for manual review (content differs)
+
+  try {
+    const entries = fs.readdirSync(shadowedDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const src = path.join(shadowedDir, entry.name);
+      const dest = path.join(skillsDir, entry.name);
+
+      try {
+        if (!fs.existsSync(dest)) {
+          fs.renameSync(src, dest);
+          restored.push(entry.name);
+        } else {
+          // Skill exists in local - verify content match before deleting orphaned copy
+          const orphanedSkill = path.join(src, 'SKILL.md');
+          const localSkill = path.join(dest, 'SKILL.md');
+          if (fs.existsSync(orphanedSkill) && fs.existsSync(localSkill)) {
+            const orphanedContent = fs.readFileSync(orphanedSkill, 'utf8');
+            const localContent = fs.readFileSync(localSkill, 'utf8');
+            if (orphanedContent === localContent) {
+              // Content identical - safe to remove orphaned duplicate
+              fs.rmSync(src, { recursive: true, force: true });
+              skipped.push(entry.name);
+            } else {
+              // Content differs - user may have edited orphaned version, keep for review
+              kept.push(entry.name);
+            }
+          } else {
+            // Missing SKILL.md - safe to remove orphaned copy
+            fs.rmSync(src, { recursive: true, force: true });
+            skipped.push(entry.name);
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`[session-init] Failed to process "${entry.name}": ${err.message}\n`);
+      }
+    }
+    // Clean up manifest and shadowed dir if empty
+    const manifestFile = path.join(shadowedDir, '.dedup-manifest.json');
+    if (fs.existsSync(manifestFile)) fs.unlinkSync(manifestFile);
+    // Only remove shadowed dir if empty (kept skills may remain)
+    const remaining = fs.readdirSync(shadowedDir);
+    if (remaining.length === 0) fs.rmdirSync(shadowedDir);
+    return { restored, skipped, kept };
+  } catch (err) {
+    process.stderr.write(`[session-init] Shadowed cleanup error: ${err.message}\n`);
+    return { restored, skipped, kept };
+  }
+}
+
+/**
+ * Detect if this session is running inside an Agent Team.
+ * Scans ~/.claude/teams/ for active team configs and checks membership.
+ * Note: Returns first team found — Claude Code supports one team per session.
+ * Note: Team lifecycle (creation/cleanup) is managed by Claude Code, not this hook.
+ * @returns {{ teamName: string, memberCount: number } | null}
+ */
+function detectAgentTeam() {
+  try {
+    const teamsDir = path.join(os.homedir(), '.claude', 'teams');
+    if (!fs.existsSync(teamsDir)) return null;
+
+    const teams = fs.readdirSync(teamsDir, { withFileTypes: true });
+    for (const entry of teams) {
+      if (!entry.isDirectory()) continue;
+      const configPath = path.join(teamsDir, entry.name, 'config.json');
+      if (!fs.existsSync(configPath)) continue;
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (config.members && config.members.length > 0) {
+          return { teamName: entry.name, memberCount: config.members.length };
+        }
+      } catch { /* skip malformed configs */ }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Main hook execution
+ */
+async function main() {
+  try {
+    // Issue #422: One-time cleanup of orphaned .shadowed/ from disabled skill-dedup hook
+    const shadowedCleanup = cleanupOrphanedShadowedSkills();
+
+    const stdin = fs.readFileSync(0, 'utf-8').trim();
+    const data = stdin ? JSON.parse(stdin) : {};
+    const envFile = process.env.CLAUDE_ENV_FILE;
+    const source = data.source || 'unknown';
+    const sessionId = data.session_id || null;
+
+    const config = loadConfig();
+
+    const detections = {
+      type: detectProjectType(config.project?.type),
+      pm: detectPackageManager(config.project?.packageManager),
+      framework: detectFramework(config.project?.framework)
+    };
+
+    // Resolve plan - now returns { path, resolvedBy }
+    const resolved = resolvePlanPath(null, config);
+
+    // CRITICAL FIX: Only persist explicitly-set plans to session state
+    // Branch-matched plans are "suggested" - stored separately, not as activePlan
+    // This prevents stale plan pollution on fresh sessions
+    if (sessionId) {
+      writeSessionState(sessionId, {
+        sessionOrigin: process.cwd(),
+        // Only session-resolved plans are truly "active"
+        activePlan: resolved.resolvedBy === 'session' ? resolved.path : null,
+        // Track suggested plan separately (for UI hints, not for report paths)
+        suggestedPlan: resolved.resolvedBy === 'branch' ? resolved.path : null,
+        timestamp: Date.now(),
+        source
+      });
+    }
+
+    // Reports path only uses active plans, not suggested ones
+    const reportsPath = getReportsPath(resolved.path, resolved.resolvedBy, config.plan, config.paths);
+
+    // Extract task list ID for Claude Code Tasks coordination (shared helper)
+    const taskListId = extractTaskListId(resolved);
+
+    // Collect static environment info (computed once per session)
+    const staticEnv = {
+      nodeVersion: process.version,
+      pythonVersion: getPythonVersion(),
+      osPlatform: process.platform,
+      gitUrl: getGitRemoteUrl(),
+      gitBranch: getGitBranch(),
+      gitRoot: getGitRoot(),
+      user: process.env.USERNAME || process.env.USER || process.env.LOGNAME || os.userInfo().username,
+      locale: process.env.LANG || '',
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      claudeSettingsDir: path.resolve(__dirname, '..')
+    };
+
+    // Compute base directory for absolute paths (Issue #327: use CWD for subdirectory support)
+    // Git root is kept in staticEnv for reference, but CWD determines where files are created
+    const baseDir = process.cwd();
+
+    // Compute resolved naming pattern (date + issue resolved, {slug} kept as placeholder)
+    const namePattern = resolveNamingPattern(config.plan, staticEnv.gitBranch);
+
+    if (envFile) {
+      // Session & plan config
+      writeEnv(envFile, 'CK_SESSION_ID', sessionId || '');
+      writeEnv(envFile, 'CK_PLAN_NAMING_FORMAT', config.plan.namingFormat);
+      writeEnv(envFile, 'CK_PLAN_DATE_FORMAT', config.plan.dateFormat);
+      writeEnv(envFile, 'CK_PLAN_ISSUE_PREFIX', config.plan.issuePrefix || '');
+      writeEnv(envFile, 'CK_PLAN_REPORTS_DIR', config.plan.reportsDir);
+
+      // NEW: Resolved naming pattern for DRY file naming in agents
+      // Example: "251212-1830-GH-88-{slug}" or "251212-1830-{slug}"
+      // Agents use: `{agent-type}-$CK_NAME_PATTERN.md` and substitute {slug}
+      writeEnv(envFile, 'CK_NAME_PATTERN', namePattern);
+
+      // Plan resolution
+      writeEnv(envFile, 'CK_ACTIVE_PLAN', resolved.resolvedBy === 'session' ? resolved.path : '');
+      writeEnv(envFile, 'CK_SUGGESTED_PLAN', resolved.resolvedBy === 'branch' ? resolved.path : '');
+
+      // Claude Code Tasks integration - enables multi-session/subagent coordination
+      // Task list ID = plan directory name (shared across all sessions working on same plan)
+      if (taskListId) {
+        writeEnv(envFile, 'CLAUDE_CODE_TASK_LIST_ID', taskListId);
+      }
+
+      // Paths - use absolute paths based on CWD for subdirectory workflow support (Issue #327)
+      writeEnv(envFile, 'CK_GIT_ROOT', staticEnv.gitRoot || '');
+      writeEnv(envFile, 'CK_REPORTS_PATH', path.join(baseDir, reportsPath));
+      writeEnv(envFile, 'CK_DOCS_PATH', path.join(baseDir, config.paths.docs));
+      writeEnv(envFile, 'CK_PLANS_PATH', path.join(baseDir, config.paths.plans));
+      writeEnv(envFile, 'CK_PROJECT_ROOT', process.cwd());
+
+      // Project detection
+      writeEnv(envFile, 'CK_PROJECT_TYPE', detections.type || '');
+      writeEnv(envFile, 'CK_PACKAGE_MANAGER', detections.pm || '');
+      writeEnv(envFile, 'CK_FRAMEWORK', detections.framework || '');
+
+      // NEW: Static environment info (so other hooks don't need to recompute)
+      writeEnv(envFile, 'CK_NODE_VERSION', staticEnv.nodeVersion);
+      writeEnv(envFile, 'CK_PYTHON_VERSION', staticEnv.pythonVersion || '');
+      writeEnv(envFile, 'CK_OS_PLATFORM', staticEnv.osPlatform);
+      writeEnv(envFile, 'CK_GIT_URL', staticEnv.gitUrl || '');
+      writeEnv(envFile, 'CK_GIT_BRANCH', staticEnv.gitBranch || '');
+      writeEnv(envFile, 'CK_USER', staticEnv.user);
+      writeEnv(envFile, 'CK_LOCALE', staticEnv.locale);
+      writeEnv(envFile, 'CK_TIMEZONE', staticEnv.timezone);
+      writeEnv(envFile, 'CK_CLAUDE_SETTINGS_DIR', staticEnv.claudeSettingsDir);
+
+      // Locale config
+      if (config.locale?.thinkingLanguage) {
+        writeEnv(envFile, 'CK_THINKING_LANGUAGE', config.locale.thinkingLanguage);
+      }
+      if (config.locale?.responseLanguage) {
+        writeEnv(envFile, 'CK_RESPONSE_LANGUAGE', config.locale.responseLanguage);
+      }
+
+      // Plan validation config (for /plan validate, /plan --hard, /plan --parallel)
+      const validation = config.plan?.validation || {};
+      writeEnv(envFile, 'CK_VALIDATION_MODE', validation.mode || 'prompt');
+      writeEnv(envFile, 'CK_VALIDATION_MIN_QUESTIONS', validation.minQuestions || 3);
+      writeEnv(envFile, 'CK_VALIDATION_MAX_QUESTIONS', validation.maxQuestions || 8);
+      writeEnv(envFile, 'CK_VALIDATION_FOCUS_AREAS', (validation.focusAreas || ['assumptions', 'risks', 'tradeoffs', 'architecture']).join(','));
+
+      // Coding level config (for output style selection)
+      const codingLevel = config.codingLevel ?? 5;
+      writeEnv(envFile, 'CK_CODING_LEVEL', codingLevel);
+      writeEnv(envFile, 'CK_CODING_LEVEL_STYLE', getCodingLevelStyleName(codingLevel));
+
+    }
+
+    // Agent Teams detection — detect once, used for env vars and console output
+    const teamInfo = detectAgentTeam();
+    if (envFile && teamInfo) {
+      writeEnv(envFile, 'CK_AGENT_TEAM', teamInfo.teamName);
+      writeEnv(envFile, 'CK_AGENT_TEAM_MEMBERS', teamInfo.memberCount);
+    }
+
+    console.log(`Session ${source}. ${buildContextOutput(config, detections, resolved, staticEnv.gitRoot)}`);
+
+    // Issue #422: Notify user if orphaned skills were recovered from .shadowed/
+    const hasCleanup = shadowedCleanup.restored.length > 0 || shadowedCleanup.skipped.length > 0 || shadowedCleanup.kept.length > 0;
+    if (hasCleanup) {
+      console.log(`\n[!] SKILL-DEDUP CLEANUP (Issue #422):`);
+      console.log(`Recovered orphaned .shadowed/ directory from disabled skill-dedup hook.`);
+      if (shadowedCleanup.restored.length > 0) {
+        console.log(`Restored ${shadowedCleanup.restored.length} skill(s): ${shadowedCleanup.restored.join(', ')}`);
+      }
+      if (shadowedCleanup.skipped.length > 0) {
+        console.log(`Removed ${shadowedCleanup.skipped.length} duplicate(s): ${shadowedCleanup.skipped.join(', ')}`);
+      }
+      if (shadowedCleanup.kept.length > 0) {
+        console.log(`[!] Kept ${shadowedCleanup.kept.length} skill(s) for manual review (content differs): ${shadowedCleanup.kept.join(', ')}`);
+        console.log(`    Review .claude/skills/.shadowed/ and merge changes manually.`);
+      }
+    }
+
+    // Agent Teams: Show team context if running inside a team (uses cached result)
+    if (teamInfo) {
+      console.log(`[i] Agent Team detected: "${teamInfo.teamName}" (${teamInfo.memberCount} members)`);
+      console.log(`    Team config: ~/.claude/teams/${teamInfo.teamName}/config.json`);
+      console.log(`    Use /team skill for orchestration templates.`);
+    }
+
+    // Info: Show git root when running from subdirectory (Issue #327: now supported)
+    if (staticEnv.gitRoot && staticEnv.gitRoot !== process.cwd()) {
+      console.log(`📁 Subdirectory mode: Plans/docs will be created in current directory`);
+      console.log(`   Git root: ${staticEnv.gitRoot}`);
+    }
+
+    // MITIGATION: Issue #277 - Auto-compact can bypass AskUserQuestion approval gates
+    // When context is compacted mid-workflow, the summarization may lose "pending approval" state.
+    // This warning reminds Claude to verify if user approval was pending before proceeding.
+    // Upstream bug: Claude Code CLI should preserve pending interactive state during compaction.
+    if (source === 'compact') {
+      console.log(`\n⚠️ CONTEXT COMPACTED - APPROVAL STATE CHECK:`);
+      console.log(`If you were waiting for user approval via AskUserQuestion (e.g., Step 4 review gate),`);
+      console.log(`you MUST re-confirm with the user before proceeding. Do NOT assume approval was given.`);
+      console.log(`Use AskUserQuestion to verify: "Context was compacted. Please confirm approval to continue."`);
+    }
+
+    // Auto-inject coding level guidelines (if not disabled)
+    const codingLevel = config.codingLevel ?? -1;
+    const guidelines = getCodingLevelGuidelines(codingLevel);
+    if (guidelines) {
+      console.log(`\n${guidelines}`);
+    }
+
+    if (config.assertions?.length > 0) {
+      console.log(`\nUser Assertions:`);
+      config.assertions.forEach((assertion, i) => {
+        console.log(`  ${i + 1}. ${assertion}`);
+      });
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error(`SessionStart hook error: ${error.message}`);
+    process.exit(0);
+  }
+  }
+
+  main();
+} catch (e) {
+  // Minimal crash logging (zero deps — only Node builtins)
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: p.basename(__filename, '.cjs'), status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}