@vinaes/succ 1.3.19

package/hooks/succ-post-tool.cjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse Hook - Auto-capture important actions
+ *
+ * Automatically saves memories for significant events:
+ * 1. Git commits - save commit message as milestone
+ * 2. New dependencies - track package additions
+ * 3. Test runs - save test results
+ * 4. File creation - note new files
+ * 5. MEMORY.md sync - auto-save bullets to long-term memory
+ * 6. Task/Explore/succ-* results - save subagent findings to long-term memory
+ *
+ * Uses daemon API for memory operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse MEMORY.md bullets, classify by section header.
+ * Returns [{ text, tags }] for each bullet worth saving.
+ */
+function parseMemoryMdBullets(content) {
+  const results = [];
+  let currentSection = '';
+
+  for (const line of content.split('\n')) {
+    const headerMatch = line.match(/^##\s+(.+)/);
+    if (headerMatch) {
+      currentSection = headerMatch[1].trim().toLowerCase();
+      continue;
+    }
+
+    const bulletMatch = line.match(/^-\s+(.+)/);
+    if (!bulletMatch) continue;
+
+    const text = bulletMatch[1].trim();
+    if (text.length < 10) continue;
+
+    const tags = ['memory-md'];
+    if (/gotcha/i.test(currentSection)) tags.push('gotcha');
+    else if (/learning|lesson/i.test(currentSection)) tags.push('learning');
+    else if (/decision|chose/i.test(currentSection)) tags.push('decision');
+    else if (/pattern/i.test(currentSection)) tags.push('pattern');
+    else if (/change|phase/i.test(currentSection)) tags.push('changelog');
+    else tags.push('observation');
+
+    results.push({ text, tags });
+  }
+
+  return results;
+}
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    let projectDir = hookInput.cwd || process.cwd();
+
+    // Windows path fix
+    if (process.platform === 'win32' && /^\/[a-z]\//.test(projectDir)) {
+      projectDir = projectDir[1].toUpperCase() + ':' + projectDir.slice(2);
+    }
+
+    // Skip if succ is not initialized in this project
+    if (!fs.existsSync(path.join(projectDir, '.succ'))) {
+      process.exit(0);
+    }
+
+    const toolName = hookInput.tool_name || '';
+    const toolInput = hookInput.tool_input || {};
+    const toolOutput = hookInput.tool_output || hookInput.tool_response || '';
+    const wasSuccess = !hookInput.tool_error;
+
+    if (!wasSuccess) {
+      process.exit(0);
+    }
+
+    // Read daemon port
+    let daemonPort = null;
+    try {
+      const portFile = path.join(projectDir, '.succ', '.tmp', 'daemon.port');
+      if (fs.existsSync(portFile)) {
+        daemonPort = parseInt(fs.readFileSync(portFile, 'utf8').trim(), 10);
+      }
+    } catch {}
+
+    if (!daemonPort) {
+      process.exit(0);
+    }
+
+    // Helper to save memory via daemon API
+    const succRemember = async (content, tagsStr) => {
+      try {
+        await fetch(`http://127.0.0.1:${daemonPort}/api/remember`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            content: content,
+            tags: tagsStr.split(','),
+            source: 'auto-capture',
+          }),
+          signal: AbortSignal.timeout(3000),
+        });
+      } catch {}
+    };
+
+    // Pattern 1: Git Commits
+    if (toolName === 'Bash' && toolInput.command) {
+      const cmd = toolInput.command;
+
+      if (/git\s+commit/i.test(cmd) && wasSuccess) {
+        const msgMatch = cmd.match(/-m\s+["']([^"']+)["']/);
+        if (msgMatch) {
+          await succRemember('Committed: ' + msgMatch[1], 'git,commit,milestone');
+        }
+      }
+
+      // npm/yarn install detection
+      if (/(?:npm|yarn|pnpm)\s+(?:install|add)\s+(\S+)/i.test(cmd) && wasSuccess) {
+        const pkgMatch = cmd.match(/(?:npm|yarn|pnpm)\s+(?:install|add)\s+(\S+)/i);
+        if (pkgMatch && pkgMatch[1] && !pkgMatch[1].startsWith('-')) {
+          await succRemember('Added dependency: ' + pkgMatch[1], 'dependency,package');
+        }
+      }
+
+      // Test run detection
+      if (/(?:npm\s+test|yarn\s+test|pytest|jest|vitest)/i.test(cmd)) {
+        const passed = /pass|success|ok|✓/i.test(toolOutput);
+        const failed = /fail|error|✗|✘/i.test(toolOutput);
+
+        if (passed && !failed) {
+          await succRemember('Tests passed after changes', 'test,success');
+        }
+      }
+    }
+
+    // Pattern 2: File Creation
+    if (toolName === 'Write' && toolInput.file_path && wasSuccess) {
+      const filePath = toolInput.file_path;
+      const relativePath = path.relative(projectDir, filePath);
+
+      if (
+        !relativePath.includes('node_modules') &&
+        !relativePath.includes('.tmp') &&
+        !relativePath.startsWith('.') &&
+        /\.(ts|tsx|js|jsx|py|go|rs|md)$/.test(relativePath)
+      ) {
+        const content = toolInput.content || '';
+        if (content.length < 5000) {
+          await succRemember('Created file: ' + relativePath, 'file,created');
+        }
+      }
+    }
+
+    // Pattern 3: Task/Explore results → save subagent findings to long-term memory
+    if (toolName === 'Task' && toolInput.subagent_type) {
+      const agentType = toolInput.subagent_type;
+      // Capture Explore, Plan, feature-dev, and all succ-* agents
+      if (/^(Explore|Plan|feature-dev|succ-)/.test(agentType)) {
+        // Extract clean text from agent response (strip JSON wrapper with status/prompt/agentId)
+        let text = '';
+        try {
+          const parsed = typeof toolOutput === 'string' ? JSON.parse(toolOutput) : toolOutput;
+          if (parsed && Array.isArray(parsed.content)) {
+            // Claude SDK format: { status, prompt, agentId, content: [{ type: "text", text: "..." }] }
+            text = parsed.content
+              .filter(c => c.type === 'text' && c.text)
+              .map(c => c.text)
+              .join('\n\n');
+          } else if (typeof parsed === 'string') {
+            text = parsed;
+          }
+        } catch {
+          text = typeof toolOutput === 'string' ? toolOutput : '';
+        }
+
+        if (text.length > 50 && text.length < 20000) {
+          // Skip if succ-* agent already saved to memory (avoid duplicates)
+          const agentAlreadySaved = /^succ-/.test(agentType) &&
+            /succ_remember|saved to memory|memory \(id:/i.test(text);
+          if (!agentAlreadySaved) {
+            const desc = (toolInput.description || '').slice(0, 100);
+            const content = `[${agentType}] ${desc}\n\n${text.slice(0, 3000)}`;
+            await succRemember(content, `subagent,${agentType.toLowerCase()},auto-capture`);
+          }
+        }
+      }
+    }
+
+    // Pattern 4: MEMORY.md sync → save bullets to long-term memory (parallel)
+    if ((toolName === 'Edit' || toolName === 'Write') && toolInput.file_path && wasSuccess) {
+      if (path.basename(toolInput.file_path) === 'MEMORY.md') {
+        try {
+          const memContent = fs.readFileSync(toolInput.file_path, 'utf8');
+          const bullets = parseMemoryMdBullets(memContent);
+          if (bullets.length > 0) {
+            await Promise.allSettled(bullets.map(bullet =>
+              fetch(`http://127.0.0.1:${daemonPort}/api/remember`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                  content: bullet.text,
+                  tags: bullet.tags,
+                  source: 'memory-md-sync',
+                }),
+                signal: AbortSignal.timeout(5000),
+              }).catch(() => {})
+            ));
+          }
+        } catch {}
+      }
+    }
+
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});

package/hooks/succ-pre-tool.cjs

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse Hook — Command safety guard + commit context injection
+ *
+ * Fires before every Bash tool call. Three features:
+ *
+ * 1. Command safety guard — blocks dangerous git/filesystem/database/docker commands
+ *    Config: commandSafetyGuard.mode = 'deny' | 'ask' | 'off' (default: 'deny')
+ *    Config: commandSafetyGuard.allowlist = string[]
+ *    Config: commandSafetyGuard.customPatterns = [{ pattern: "regex", reason: "why" }]
+ *
+ * 2. Commit guidelines injection — injects co-author format into context
+ *    when Claude is about to run git commit
+ *    Config: includeCoAuthoredBy (default: true)
+ *
+ * 3. Pre-commit diff review reminder — injects reminder to run diff-reviewer
+ *    Config: preCommitReview (default: false)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ─── Dangerous command patterns ──────────────────────────────────────
+
+const DANGEROUS_PATTERNS = [
+  // ── Git — data loss ──
+  { pattern: /\bgit\s+reset\s+--hard\b/, reason: 'git reset --hard destroys uncommitted changes. Use git stash first.' },
+  { pattern: /\bgit\s+reset\s+--merge\b/, reason: 'git reset --merge can destroy uncommitted changes.' },
+  { pattern: /\bgit\s+checkout\s+--\s/, reason: 'git checkout -- discards file modifications. Use git stash first.' },
+  { pattern: /\bgit\s+checkout\s+\.\s*($|[;&|])/, reason: 'git checkout . discards all modifications. Use git stash first.' },
+  { pattern: /\bgit\s+restore\s+--staged\s+--worktree\b/, reason: 'git restore --staged --worktree discards both staged and unstaged changes.' },
+  { pattern: /\bgit\s+clean\s+-[a-zA-Z]*f/, reason: 'git clean -f permanently deletes untracked files.' },
+  { pattern: /\bgit\s+push\s+.*--force(?!-with-lease)\b/, reason: 'git push --force rewrites remote history. Use --force-with-lease instead.' },
+  { pattern: /\bgit\s+push\s+-f\b/, reason: 'git push -f rewrites remote history. Use --force-with-lease instead.' },
+  { pattern: /\bgit\s+branch\s+-D\b/, reason: 'git branch -D force-deletes without merge verification. Use -d for safe delete.' },
+  { pattern: /\bgit\s+stash\s+drop\b/, reason: 'git stash drop permanently destroys stashed work.' },
+  { pattern: /\bgit\s+stash\s+clear\b/, reason: 'git stash clear destroys ALL stashed work.' },
+  { pattern: /\bgit\s+rebase\s+-i\b/, reason: 'git rebase -i requires interactive terminal (not available in hooks).' },
+  { pattern: /\bgit\s+reflog\s+expire\s+--expire=now\b/, reason: 'git reflog expire --expire=now permanently removes recovery points.' },
+
+  // ── Filesystem — data loss ──
+  { pattern: /\brm\s+.*\.succ\b/, reason: '.succ/ contains your memory, brain vault, and config. This would destroy all succ data.' },
+  { pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\b/, reason: 'rm -rf can permanently delete files. Verify the target path.', checkPath: true },
+  { pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\b/, reason: 'rm -fr can permanently delete files. Verify the target path.', checkPath: true },
+
+  // ── Docker — container/image/volume destruction ──
+  { pattern: /\bdocker\s+system\s+prune\b/, reason: 'docker system prune removes all unused containers, networks, images, and optionally volumes.' },
+  { pattern: /\bdocker\s+volume\s+prune\b/, reason: 'docker volume prune removes all unused volumes (potential data loss).' },
+  { pattern: /\bdocker\s+rm\s+-f\b/, reason: 'docker rm -f force-removes running containers without graceful shutdown.' },
+  { pattern: /\bdocker\s+rmi\s+-f\b/, reason: 'docker rmi -f force-removes images that may be in use.' },
+  { pattern: /\bdocker-compose\s+down\s+-v\b/, reason: 'docker-compose down -v removes named volumes (database data loss).' },
+  { pattern: /\bdocker\s+compose\s+down\s+-v\b/, reason: 'docker compose down -v removes named volumes (database data loss).' },
+
+  // ── SQLite — database destruction ──
+  { pattern: /\bsqlite3?\b.*\bDROP\s+TABLE\b/i, reason: 'DROP TABLE permanently deletes a SQLite table and all its data.' },
+  { pattern: /\bsqlite3?\b.*\bDROP\s+DATABASE\b/i, reason: 'DROP DATABASE permanently deletes the entire SQLite database.' },
+  { pattern: /\bsqlite3?\b.*\bDELETE\s+FROM\s+\w+\s*;/i, reason: 'DELETE FROM without WHERE deletes all rows in a SQLite table.' },
+  { pattern: /\bsqlite3?\b.*\bTRUNCATE\b/i, reason: 'TRUNCATE removes all data from a SQLite table.' },
+
+  // ── PostgreSQL — database destruction ──
+  { pattern: /\bpsql\b.*\bDROP\s+TABLE\b/i, reason: 'DROP TABLE permanently deletes a PostgreSQL table and all its data.' },
+  { pattern: /\bpsql\b.*\bDROP\s+DATABASE\b/i, reason: 'DROP DATABASE permanently deletes the entire PostgreSQL database.' },
+  { pattern: /\bpsql\b.*\bDELETE\s+FROM\s+\w+\s*;/i, reason: 'DELETE FROM without WHERE deletes all rows in a PostgreSQL table.' },
+  { pattern: /\bpsql\b.*\bTRUNCATE\b/i, reason: 'TRUNCATE removes all data from a PostgreSQL table.' },
+  { pattern: /\bdropdb\b/, reason: 'dropdb permanently deletes a PostgreSQL database.' },
+  { pattern: /\bdropuser\b/, reason: 'dropuser permanently deletes a PostgreSQL user/role.' },
+
+  // ── Qdrant — vector database destruction ──
+  { pattern: /\bcurl\b.*\bqdrant\b.*\bDELETE\b/i, reason: 'DELETE on Qdrant API can remove collections or points permanently.' },
+  { pattern: /\bcurl\b.*\b:6333\b.*\bDELETE\b/i, reason: 'DELETE on Qdrant port 6333 can remove collections or points permanently.' },
+  { pattern: /\bcurl\b.*\b:6334\b.*\bDELETE\b/i, reason: 'DELETE on Qdrant gRPC port can remove data permanently.' },
+];
+
+// Paths where rm -rf is considered safe (normalized, lowercase)
+const SAFE_RM_PATHS = [
+  '/tmp', '/var/tmp',
+  'node_modules', 'dist', 'build', '.cache',
+  '__pycache__', '.pytest_cache', '.tox',
+  'target/debug', 'target/release',
+  '.next', '.nuxt', '.turbo', 'coverage',
+];
+
+// Prefixes that indicate the command is data, not execution
+const DATA_PREFIXES = [
+  /^\s*(?:#|\/\/)/,           // comments
+  /^\s*echo\b/,              // echo
+  /^\s*printf\b/,            // printf
+  /^\s*cat\s*<</,            // heredoc (cat <<)
+  /^\s*grep\b/,              // grep
+  /^\s*rg\b/,                // ripgrep
+  /^\s*ag\b/,                // silver searcher
+  /^\s*(?:"|').*(?:"|')\s*$/,// quoted string
+];
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function loadConfig(projectDir) {
+  const defaults = {
+    commandSafetyGuard: { mode: 'deny', allowlist: [], customPatterns: [] },
+    includeCoAuthoredBy: true,
+    preCommitReview: false,
+  };
+
+  const configPaths = [
+    path.join(projectDir, '.succ', 'config.json'),
+    path.join(require('os').homedir(), '.succ', 'config.json'),
+  ];
+
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+        // Command safety guard
+        if (config.commandSafetyGuard) {
+          if (config.commandSafetyGuard.mode) {
+            defaults.commandSafetyGuard.mode = config.commandSafetyGuard.mode;
+          }
+          if (Array.isArray(config.commandSafetyGuard.allowlist)) {
+            defaults.commandSafetyGuard.allowlist = config.commandSafetyGuard.allowlist;
+          }
+          if (Array.isArray(config.commandSafetyGuard.customPatterns)) {
+            defaults.commandSafetyGuard.customPatterns = config.commandSafetyGuard.customPatterns;
+          }
+        }
+
+        if (config.includeCoAuthoredBy === false) {
+          defaults.includeCoAuthoredBy = false;
+        }
+        if (config.preCommitReview === true) {
+          defaults.preCommitReview = true;
+        }
+
+        break;
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+
+  return defaults;
+}
+
+function isDataContext(command) {
+  const trimmed = command.trim();
+  return DATA_PREFIXES.some(prefix => prefix.test(trimmed));
+}
+
+function isRmPathSafe(command) {
+  const match = command.match(/\brm\s+-[a-zA-Z]*(?:rf|fr)[a-zA-Z]*\s+(.+?)(?:\s*[;&|]|$)/);
+  if (!match) return false;
+
+  const target = match[1].trim().replace(/["']/g, '');
+  const normalized = target.toLowerCase().replace(/\\/g, '/');
+
+  return SAFE_RM_PATHS.some(safe => {
+    if (normalized === safe || normalized.endsWith('/' + safe)) return true;
+    if (safe === '/tmp' && normalized.startsWith('/tmp/')) return true;
+    if (safe === '/var/tmp' && normalized.startsWith('/var/tmp/')) return true;
+    return false;
+  });
+}
+
+function checkDangerous(command, config) {
+  if (config.commandSafetyGuard.mode === 'off') return null;
+
+  // Check allowlist first
+  const allowlist = config.commandSafetyGuard.allowlist || [];
+  for (const allowed of allowlist) {
+    if (command.includes(allowed)) return null;
+  }
+
+  // Skip if command is in a data context
+  if (isDataContext(command)) return null;
+
+  // Check built-in patterns
+  for (const { pattern, reason, checkPath } of DANGEROUS_PATTERNS) {
+    if (pattern.test(command)) {
+      if (checkPath && isRmPathSafe(command)) continue;
+
+      return {
+        reason,
+        mode: config.commandSafetyGuard.mode,
+      };
+    }
+  }
+
+  // Check user-defined custom patterns (blacklist)
+  const customPatterns = config.commandSafetyGuard.customPatterns || [];
+  for (const custom of customPatterns) {
+    try {
+      const regex = new RegExp(custom.pattern, custom.flags || '');
+      if (regex.test(command)) {
+        return {
+          reason: custom.reason || `Blocked by custom pattern: ${custom.pattern}`,
+          mode: config.commandSafetyGuard.mode,
+        };
+      }
+    } catch {
+      // Invalid regex in config — skip silently
+    }
+  }
+
+  return null;
+}
+
+function buildCommitContext(config) {
+  const parts = [];
+
+  if (config.includeCoAuthoredBy) {
+    parts.push(`<commit-format>
+Footer order (succ always LAST):
+1. Generated with [Claude Code]
+2. via [Happy] (if used)
+3. powered by [succ](https://succ.ai)
+
+Co-Authored-By order (succ always LAST):
+1. Co-Authored-By: Claude <noreply@anthropic.com>
+2. Co-Authored-By: Happy <yesreply@happy.engineering> (if used)
+3. Co-Authored-By: succ <mindpalace@succ.ai>
+</commit-format>`);
+  }
+
+  if (config.preCommitReview) {
+    parts.push(`<pre-commit-review>
+STOP. Before committing, you MUST run the succ-diff-reviewer agent first.
+Use: Task tool with subagent_type="succ-diff-reviewer"
+Prompt: "Review the staged git diff for bugs, security issues, and regressions before commit"
+
+If diff-reviewer finds CRITICAL issues — do NOT commit until fixed.
+If diff-reviewer finds HIGH issues — warn the user before committing.
+MEDIUM and below — commit is OK, mention findings in summary.
+</pre-commit-review>`);
+  }
+
+  return parts.join('\n');
+}
+
+// ─── Main ────────────────────────────────────────────────────────────
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const hookInput = JSON.parse(input);
+    let projectDir = hookInput.cwd || process.cwd();
+
+    // Windows path fix
+    if (process.platform === 'win32' && /^\/[a-z]\//.test(projectDir)) {
+      projectDir = projectDir[1].toUpperCase() + ':' + projectDir.slice(2);
+    }
+
+    // Skip if this is a service session (daemon, reflection agent, etc.)
+    if (process.env.SUCC_SERVICE_SESSION === '1') {
+      process.exit(0);
+    }
+
+    // Skip if succ is not initialized
+    if (!fs.existsSync(path.join(projectDir, '.succ'))) {
+      process.exit(0);
+    }
+
+    const command = hookInput.tool_input?.command || '';
+    if (!command) {
+      process.exit(0);
+    }
+
+    const config = loadConfig(projectDir);
+
+    // 1. Command safety guard
+    const dangerousResult = checkDangerous(command, config);
+    if (dangerousResult) {
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: dangerousResult.mode === 'ask' ? 'ask' : 'deny',
+          permissionDecisionReason: `[succ guard] ${dangerousResult.reason}`,
+        },
+      };
+      console.log(JSON.stringify(output));
+      process.exit(0);
+    }
+
+    // 2. Git commit — inject guidelines + diff review reminder
+    if (/\bgit\s+commit\b/.test(command)) {
+      const additionalContext = buildCommitContext(config);
+      if (additionalContext) {
+        const output = {
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            additionalContext,
+          },
+        };
+        console.log(JSON.stringify(output));
+        process.exit(0);
+      }
+    }
+
+    // No action needed
+    process.exit(0);
+  } catch {
+    // Fail-open: don't block on hook errors
+    process.exit(0);
+  }
+});

package/hooks/succ-session-end.cjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * SessionEnd Hook - Notify daemon to process session
+ *
+ * Minimal hook that just tells daemon to:
+ * 1. Unregister the session
+ * 2. Process transcript asynchronously (summarize, extract learnings, save to memory)
+ *
+ * All heavy lifting is done by daemon after hook exits.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', async () => {
+  try {
+    const hookInput = JSON.parse(input);
+    let projectDir = hookInput.cwd || process.cwd();
+
+    // Windows path fix
+    if (process.platform === 'win32' && /^\/[a-z]\//.test(projectDir)) {
+      projectDir = projectDir[1].toUpperCase() + ':' + projectDir.slice(2);
+    }
+
+    // Skip if succ is not initialized in this project
+    if (!fs.existsSync(path.join(projectDir, '.succ'))) {
+      process.exit(0);
+    }
+
+    // Read daemon port
+    const portFile = path.join(projectDir, '.succ', '.tmp', 'daemon.port');
+    let daemonPort = null;
+    try {
+      if (fs.existsSync(portFile)) {
+        daemonPort = parseInt(fs.readFileSync(portFile, 'utf8').trim(), 10);
+      }
+    } catch {}
+
+    if (!daemonPort) {
+      process.exit(0);
+    }
+
+    // Get session info
+    const transcriptPath = hookInput.transcript_path || '';
+    const sessionId = transcriptPath ? path.basename(transcriptPath, '.jsonl') : null;
+
+    if (!sessionId) {
+      process.exit(0);
+    }
+
+    // Skip reflection for service sessions (internal Claude calls from succ)
+    // This prevents infinite loop: session-end -> processSessionEnd -> runClaudeCLI -> session-end -> ...
+    const isServiceSession = process.env.SUCC_SERVICE_SESSION === '1';
+
+    // Tell daemon to unregister and process session
+    // Daemon will handle transcript parsing, summarization, and memory saving asynchronously
+    try {
+      await fetch(`http://127.0.0.1:${daemonPort}/api/session/unregister`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          session_id: sessionId,
+          transcript_path: transcriptPath,
+          run_reflection: !isServiceSession,  // Don't run reflection for service sessions
+        }),
+        signal: AbortSignal.timeout(5000),
+      });
+    } catch {
+      // Daemon communication failed, exit anyway
+    }
+
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});