sumulige-claude 1.3.2 → 1.3.3

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [1.3.3](https://github.com/sumulige/sumulige-claude/compare/v1.3.2...v1.3.3) (2026-01-22)
+
+### ✨ New Features
+
+- **`smc sync --hooks`**: Incremental hooks update for existing projects
+  - Adds new lifecycle hooks without overwriting customizations
+  - Merges SessionStart/SessionEnd/PreCompact into existing settings.json
+
+### 📝 Documentation
+
+- Add Layer 7: Lifecycle Hooks section to README
+- Document update methods for other projects
+
+---
+
 ## [1.3.2](https://github.com/sumulige/sumulige-claude/compare/v1.3.1...v1.3.2) (2026-01-22)
 
 ### ✨ New Features

package/README.md

@@ -400,6 +400,68 @@ smc skill:create my-skill
 
 ---
 
+## Layer 7: Lifecycle Hooks / 第七层：生命周期钩子
+
+### Auto-Sync System / 自动同步系统
+
+> v1.3.2: 利用 Claude Code 官方 Hook 事件实现记忆自动同步
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  SessionStart ──► memory-loader.cjs                         │
+│    └─ 自动加载 MEMORY.md, ANCHORS.md, TODO 状态              │
+│                                                              │
+│  PreCompact ──► auto-handoff.cjs                            │
+│    └─ 上下文压缩前自动生成 handoff 文档                       │
+│                                                              │
+│  SessionEnd ──► memory-saver.cjs                            │
+│    └─ 会话结束自动保存摘要到 MEMORY.md                        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Hook Files / 钩子文件
+
+| Hook | 文件 | 触发时机 | 功能 |
+|------|------|----------|------|
+| `SessionStart` | `memory-loader.cjs` | 会话开始 | 加载记忆、锚点、TODO |
+| `SessionEnd` | `memory-saver.cjs` | 会话结束 | 保存摘要、归档会话 |
+| `PreCompact` | `auto-handoff.cjs` | 上下文压缩前 | 生成 handoff 保护上下文 |
+
+### Handoff Documents / 交接文档
+
+当上下文即将被压缩时，自动生成交接文档：
+
+```
+.claude/handoffs/
+├── LATEST.md           # 最新交接文档
+├── INDEX.md            # 交接文档索引
+└── handoff_*.md        # 历史交接文档
+```
+
+每个交接文档包含：
+- 会话信息（项目、版本、开始时间）
+- 活跃 TODOs 列表
+- 最近修改的文件
+- 恢复命令
+
+### Update Hooks / 更新钩子
+
+其他项目如何获取新 hooks：
+
+```bash
+# 方式 1: 完整更新（推荐）
+smc template --force
+
+# 方式 2: 增量同步（仅更新 hooks）
+smc sync --hooks
+
+# 方式 3: 手动安装
+npm update -g sumulige-claude
+smc template
+```
+
+---
+
 ## Documentation / 文档
 
 - **[Development Guide / 开发指南](docs/DEVELOPMENT.md)** - Architecture, adding skills / 架构、添加技能

package/cli.js

@@ -30,7 +30,7 @@ const COMMANDS = {
   },
   sync: {
     help: 'Sync to current project (auto-migrates old format)',
-    args: '[--check-update]'
+    args: '[--check-update] [--hooks]'
   },
   migrate: {
     help: 'Migrate old hooks format to new',

package/lib/commands.js

@@ -335,6 +335,7 @@ const commands = {
   // -------------------------------------------------------------------------
   sync: async (...args) => {
     const forceCheckUpdate = args.includes("--check-update");
+    const syncHooks = args.includes("--hooks");
 
     console.log("🔄 Syncing Sumulige Claude to current project...");
     console.log("");
@@ -387,6 +388,88 @@ const commands = {
       }
     }
 
+    // Sync hooks if --hooks flag is provided
+    if (syncHooks) {
+      const templateHooksDir = path.join(TEMPLATE_DIR, ".claude", "hooks");
+      const projectHooksDir = path.join(projectConfigDir, "hooks");
+      const templateSettingsFile = path.join(
+        TEMPLATE_DIR,
+        ".claude",
+        "settings.json",
+      );
+      const projectSettingsFile = path.join(projectConfigDir, "settings.json");
+
+      if (fs.existsSync(templateHooksDir)) {
+        ensureDir(projectHooksDir);
+
+        // Sync hook files (only add new ones, don't overwrite)
+        const hookFiles = fs
+          .readdirSync(templateHooksDir)
+          .filter((f) => f.endsWith(".cjs"));
+        let syncedCount = 0;
+
+        hookFiles.forEach((hookFile) => {
+          const src = path.join(templateHooksDir, hookFile);
+          const dest = path.join(projectHooksDir, hookFile);
+
+          if (!fs.existsSync(dest)) {
+            fs.copyFileSync(src, dest);
+            setExecutablePermission(dest);
+            syncedCount++;
+            console.log(`   ✅ Added ${hookFile}`);
+          }
+        });
+
+        if (syncedCount > 0) {
+          console.log(`✅ Synced ${syncedCount} new hook(s)`);
+        } else {
+          console.log("✅ Hooks up to date");
+        }
+      }
+
+      // Sync settings.json (merge new lifecycle hooks)
+      if (
+        fs.existsSync(templateSettingsFile) &&
+        fs.existsSync(projectSettingsFile)
+      ) {
+        try {
+          const templateSettings = JSON.parse(
+            fs.readFileSync(templateSettingsFile, "utf-8"),
+          );
+          const projectSettings = JSON.parse(
+            fs.readFileSync(projectSettingsFile, "utf-8"),
+          );
+
+          // Merge new lifecycle hooks
+          const lifecycleHooks = [
+            "SessionStart",
+            "SessionEnd",
+            "PreCompact",
+            "env",
+          ];
+          let updated = false;
+
+          lifecycleHooks.forEach((hook) => {
+            if (templateSettings[hook] && !projectSettings[hook]) {
+              projectSettings[hook] = templateSettings[hook];
+              updated = true;
+              console.log(`   ✅ Added ${hook} hook`);
+            }
+          });
+
+          if (updated) {
+            fs.writeFileSync(
+              projectSettingsFile,
+              JSON.stringify(projectSettings, null, 2),
+            );
+            console.log("✅ Updated settings.json");
+          }
+        } catch (e) {
+          console.log("⚠️  Failed to merge settings.json");
+        }
+      }
+    }
+
     // Sync todos directory structure
     const todosTemplateDir = path.join(TEMPLATE_DIR, "development", "todos");
     const todosProjectDir = path.join(projectDir, "development", "todos");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sumulige-claude",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "The Best Agent Harness for Claude Code",
   "main": "cli.js",
   "bin": {

package/template/.claude/hooks/auto-handoff.cjs

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+/**
+ * Auto Handoff Hook - PreCompact Context Preservation
+ *
+ * Claude Official Hook: PreCompact
+ * Triggered: Before conversation context is compressed
+ *
+ * Features:
+ * - Auto-generate handoff document before context compression
+ * - Preserve critical context that might be lost during compaction
+ * - Save current state including progress, blockers, and next steps
+ *
+ * Environment Variables:
+ * - CLAUDE_PROJECT_DIR: Project directory path
+ * - CLAUDE_SESSION_ID: Unique session identifier
+ * - CLAUDE_CONVERSATION_ID: Conversation identifier
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CLAUDE_DIR = path.join(PROJECT_DIR, '.claude');
+const HANDOFFS_DIR = path.join(CLAUDE_DIR, 'handoffs');
+const SESSION_STATE_FILE = path.join(CLAUDE_DIR, '.session-state.json');
+const STATE_FILE = path.join(PROJECT_DIR, 'development', 'todos', '.state.json');
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || 'unknown';
+const CONVERSATION_ID = process.env.CLAUDE_CONVERSATION_ID || 'unknown';
+
+/**
+ * Ensure handoffs directory exists
+ */
+function ensureHandoffsDir() {
+  if (!fs.existsSync(HANDOFFS_DIR)) {
+    fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load current session state
+ */
+function loadSessionState() {
+  if (!fs.existsSync(SESSION_STATE_FILE)) {
+    return {
+      session: { project: path.basename(PROJECT_DIR) },
+      memory: { entries: 0 },
+      todos: { active: 0, completed: 0 }
+    };
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(SESSION_STATE_FILE, 'utf-8'));
+  } catch (e) {
+    return {
+      session: { project: path.basename(PROJECT_DIR) },
+      memory: { entries: 0 },
+      todos: { active: 0, completed: 0 }
+    };
+  }
+}
+
+/**
+ * Load active TODOs
+ */
+function loadActiveTodos() {
+  const todosDir = path.join(PROJECT_DIR, 'development', 'todos', 'active');
+  if (!fs.existsSync(todosDir)) {
+    return [];
+  }
+
+  try {
+    const files = fs.readdirSync(todosDir)
+      .filter(f => f.endsWith('.md') && f !== '_README.md');
+
+    return files.map(f => {
+      const content = fs.readFileSync(path.join(todosDir, f), 'utf-8');
+      const titleMatch = content.match(/^#\s+(.+)$/m);
+      return {
+        file: f,
+        title: titleMatch ? titleMatch[1] : path.basename(f, '.md')
+      };
+    });
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Get recently modified files
+ */
+function getRecentlyModifiedFiles(hours = 24) {
+  const recentFiles = [];
+  const cutoff = Date.now() - (hours * 60 * 60 * 1000);
+
+  // Check common source directories
+  const sourceDirs = ['src', 'lib', '.claude', 'development'];
+
+  for (const dir of sourceDirs) {
+    const fullPath = path.join(PROJECT_DIR, dir);
+    if (!fs.existsSync(fullPath)) continue;
+
+    try {
+      const walkDir = (dirPath, depth = 0) => {
+        if (depth > 3) return; // Limit depth
+
+        const items = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const item of items) {
+          const itemPath = path.join(dirPath, item.name);
+
+          if (item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules') {
+            walkDir(itemPath, depth + 1);
+          } else if (item.isFile()) {
+            try {
+              const stat = fs.statSync(itemPath);
+              if (stat.mtimeMs > cutoff) {
+                const relativePath = path.relative(PROJECT_DIR, itemPath);
+                recentFiles.push({
+                  path: relativePath,
+                  modified: stat.mtime.toISOString()
+                });
+              }
+            } catch (e) {
+              // Ignore stat errors
+            }
+          }
+        }
+      };
+
+      walkDir(fullPath);
+    } catch (e) {
+      // Ignore directory errors
+    }
+  }
+
+  // Sort by modification time (most recent first)
+  recentFiles.sort((a, b) => b.modified.localeCompare(a.modified));
+
+  return recentFiles.slice(0, 20); // Return top 20
+}
+
+/**
+ * Generate handoff document
+ */
+function generateHandoff(sessionState) {
+  const now = new Date();
+  const todos = loadActiveTodos();
+  const recentFiles = getRecentlyModifiedFiles();
+
+  let content = `# Handoff: Pre-Compact Context Preservation
+
+> Auto-generated before context compression
+> Date: ${now.toISOString()}
+> Session: ${SESSION_ID}
+> Conversation: ${CONVERSATION_ID}
+
+---
+
+## Session Info
+
+- **Project**: ${sessionState.session?.project || 'unknown'}
+- **Version**: ${sessionState.session?.version || 'unknown'}
+- **Start Time**: ${sessionState.session?.startTime || 'unknown'}
+
+---
+
+## Memory State
+
+- **Entries Loaded**: ${sessionState.memory?.entries || 0}
+- **Anchors Modules**: ${sessionState.anchors?.modules || 0}
+
+---
+
+## Active TODOs (${todos.length})
+
+`;
+
+  if (todos.length > 0) {
+    todos.forEach(todo => {
+      content += `- [ ] ${todo.title} (\`${todo.file}\`)\n`;
+    });
+  } else {
+    content += `*No active TODOs*\n`;
+  }
+
+  content += `
+
+---
+
+## Recently Modified Files (Last 24h)
+
+`;
+
+  if (recentFiles.length > 0) {
+    recentFiles.slice(0, 10).forEach(f => {
+      content += `- \`${f.path}\` (${f.modified.split('T')[0]})\n`;
+    });
+    if (recentFiles.length > 10) {
+      content += `- *...and ${recentFiles.length - 10} more files*\n`;
+    }
+  } else {
+    content += `*No recently modified files*\n`;
+  }
+
+  content += `
+
+---
+
+## Context Preservation Notes
+
+**Important**: This handoff was auto-generated before context compaction.
+The following information should be re-loaded after compaction:
+
+1. Read \`.claude/MEMORY.md\` for recent session context
+2. Check \`development/todos/INDEX.md\` for task status
+3. Review recent git commits for code changes
+
+---
+
+## Recovery Commands
+
+\`\`\`bash
+# View recent memory
+cat .claude/MEMORY.md | head -100
+
+# Check active TODOs
+ls development/todos/active/
+
+# View recent changes
+git log --oneline -10
+git status
+\`\`\`
+
+---
+
+*Auto-generated by auto-handoff.cjs at ${now.toISOString()}*
+`;
+
+  return content;
+}
+
+/**
+ * Save handoff document
+ */
+function saveHandoff(content) {
+  ensureHandoffsDir();
+
+  const now = new Date();
+  const filename = `handoff_${now.toISOString().replace(/[:.]/g, '-')}.md`;
+  const filepath = path.join(HANDOFFS_DIR, filename);
+
+  fs.writeFileSync(filepath, content);
+
+  // Also save as latest handoff for easy access
+  const latestPath = path.join(HANDOFFS_DIR, 'LATEST.md');
+  fs.writeFileSync(latestPath, content);
+
+  // Clean up old handoffs (keep last 10)
+  const files = fs.readdirSync(HANDOFFS_DIR)
+    .filter(f => f.startsWith('handoff_') && f.endsWith('.md'))
+    .sort()
+    .reverse();
+
+  if (files.length > 10) {
+    files.slice(10).forEach(f => {
+      try {
+        fs.unlinkSync(path.join(HANDOFFS_DIR, f));
+      } catch (e) {
+        // Ignore deletion errors
+      }
+    });
+  }
+
+  return filename;
+}
+
+/**
+ * Update handoffs index
+ */
+function updateHandoffsIndex() {
+  const indexPath = path.join(HANDOFFS_DIR, 'INDEX.md');
+
+  const files = fs.readdirSync(HANDOFFS_DIR)
+    .filter(f => f.startsWith('handoff_') && f.endsWith('.md'))
+    .sort()
+    .reverse();
+
+  let content = `# Handoffs Index
+
+> Auto-generated context preservation documents
+> Updated: ${new Date().toISOString()}
+
+---
+
+## Recent Handoffs (${files.length})
+
+`;
+
+  files.slice(0, 20).forEach(f => {
+    const filepath = path.join(HANDOFFS_DIR, f);
+    const stat = fs.statSync(filepath);
+    content += `- [${f}](./${f}) - ${stat.mtime.toISOString()}\n`;
+  });
+
+  content += `
+
+---
+
+## Latest Handoff
+
+See [LATEST.md](./LATEST.md) for the most recent context snapshot.
+
+---
+
+*Index maintained by auto-handoff.cjs*
+`;
+
+  fs.writeFileSync(indexPath, content);
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  try {
+    const sessionState = loadSessionState();
+    const content = generateHandoff(sessionState);
+    const filename = saveHandoff(content);
+    updateHandoffsIndex();
+
+    console.log(`\n⚡ PreCompact: Context preserved → ${filename}`);
+    console.log(`   Recovery: .claude/handoffs/LATEST.md\n`);
+
+    process.exit(0);
+  } catch (e) {
+    // Silent failure - don't interrupt compaction
+    console.error(`PreCompact handoff error: ${e.message}`);
+    process.exit(0);
+  }
+}
+
+// Run
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  loadSessionState,
+  loadActiveTodos,
+  getRecentlyModifiedFiles,
+  generateHandoff,
+  saveHandoff,
+  updateHandoffsIndex
+};

package/template/.claude/hooks/memory-loader.cjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Memory Loader Hook - SessionStart Auto-Load System
+ *
+ * Claude Official Hook: SessionStart
+ * Triggered: Once at the beginning of each session
+ *
+ * Features:
+ * - Auto-load MEMORY.md for recent context
+ * - Auto-load ANCHORS.md for module navigation
+ * - Restore TODO state from .state.json
+ * - Inject session context summary
+ *
+ * Environment Variables:
+ * - CLAUDE_PROJECT_DIR: Project directory path
+ * - CLAUDE_SESSION_ID: Unique session identifier
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CLAUDE_DIR = path.join(PROJECT_DIR, '.claude');
+const MEMORY_FILE = path.join(CLAUDE_DIR, 'MEMORY.md');
+const ANCHORS_FILE = path.join(CLAUDE_DIR, 'ANCHORS.md');
+const STATE_FILE = path.join(PROJECT_DIR, 'development', 'todos', '.state.json');
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || 'unknown';
+
+/**
+ * Load memory file content (recent entries only)
+ */
+function loadMemory(days = 7) {
+  if (!fs.existsSync(MEMORY_FILE)) {
+    return { exists: false, content: '', entries: 0 };
+  }
+
+  const content = fs.readFileSync(MEMORY_FILE, 'utf-8');
+  const entries = content.split('## ').slice(1, days + 1);
+
+  return {
+    exists: true,
+    content: entries.length > 0 ? '## ' + entries.join('## ') : '',
+    entries: entries.length
+  };
+}
+
+/**
+ * Load anchors file for quick navigation
+ */
+function loadAnchors() {
+  if (!fs.existsSync(ANCHORS_FILE)) {
+    return { exists: false, content: '', modules: 0 };
+  }
+
+  const content = fs.readFileSync(ANCHORS_FILE, 'utf-8');
+  const moduleMatches = content.match(/##\s+[\w-]+/g) || [];
+
+  return {
+    exists: true,
+    content: content,
+    modules: moduleMatches.length
+  };
+}
+
+/**
+ * Load TODO state
+ */
+function loadTodoState() {
+  if (!fs.existsSync(STATE_FILE)) {
+    return { exists: false, active: 0, completed: 0 };
+  }
+
+  try {
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    return {
+      exists: true,
+      active: state.active?.length || 0,
+      completed: state.completed?.length || 0,
+      lastUpdated: state.lastUpdated || null
+    };
+  } catch (e) {
+    return { exists: false, active: 0, completed: 0 };
+  }
+}
+
+/**
+ * Get project info
+ */
+function getProjectInfo() {
+  const pkgPath = path.join(PROJECT_DIR, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return { name: path.basename(PROJECT_DIR), version: 'unknown' };
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return {
+      name: pkg.name || path.basename(PROJECT_DIR),
+      version: pkg.version || 'unknown'
+    };
+  } catch (e) {
+    return { name: path.basename(PROJECT_DIR), version: 'unknown' };
+  }
+}
+
+/**
+ * Generate session start context
+ */
+function generateSessionContext() {
+  const memory = loadMemory();
+  const anchors = loadAnchors();
+  const todos = loadTodoState();
+  const project = getProjectInfo();
+
+  const timestamp = new Date().toISOString();
+
+  // Build context object
+  const context = {
+    session: {
+      id: SESSION_ID,
+      startTime: timestamp,
+      project: project.name,
+      version: project.version
+    },
+    memory: {
+      loaded: memory.exists,
+      entries: memory.entries
+    },
+    anchors: {
+      loaded: anchors.exists,
+      modules: anchors.modules
+    },
+    todos: {
+      loaded: todos.exists,
+      active: todos.active,
+      completed: todos.completed
+    }
+  };
+
+  // Save session state
+  const sessionStateFile = path.join(CLAUDE_DIR, '.session-state.json');
+  try {
+    fs.writeFileSync(sessionStateFile, JSON.stringify(context, null, 2));
+  } catch (e) {
+    // Ignore write errors
+  }
+
+  return context;
+}
+
+/**
+ * Format session summary for output
+ */
+function formatSessionSummary(context) {
+  let summary = '';
+
+  summary += `\n📂 Session: ${context.session.project} v${context.session.version}\n`;
+
+  if (context.memory.loaded && context.memory.entries > 0) {
+    summary += `💾 Memory: ${context.memory.entries} entries loaded\n`;
+  }
+
+  if (context.anchors.loaded && context.anchors.modules > 0) {
+    summary += `🔖 Anchors: ${context.anchors.modules} modules indexed\n`;
+  }
+
+  if (context.todos.loaded && (context.todos.active > 0 || context.todos.completed > 0)) {
+    summary += `📋 TODOs: ${context.todos.active} active, ${context.todos.completed} completed\n`;
+  }
+
+  return summary;
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  try {
+    const context = generateSessionContext();
+
+    // Only output summary if there's meaningful context
+    const hasContext = context.memory.entries > 0 ||
+                       context.anchors.modules > 0 ||
+                       context.todos.active > 0;
+
+    if (hasContext) {
+      console.log(formatSessionSummary(context));
+    }
+
+    process.exit(0);
+  } catch (e) {
+    // Silent failure - don't interrupt session
+    process.exit(0);
+  }
+}
+
+// Run
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  loadMemory,
+  loadAnchors,
+  loadTodoState,
+  generateSessionContext,
+  formatSessionSummary
+};

package/template/.claude/hooks/memory-saver.cjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+/**
+ * Memory Saver Hook - SessionEnd Auto-Save System
+ *
+ * Claude Official Hook: SessionEnd
+ * Triggered: Once at the end of each session
+ *
+ * Features:
+ * - Auto-save session summary to MEMORY.md
+ * - Sync TODO state changes
+ * - Archive session state
+ * - Generate session statistics
+ *
+ * Environment Variables:
+ * - CLAUDE_PROJECT_DIR: Project directory path
+ * - CLAUDE_SESSION_ID: Unique session identifier
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CLAUDE_DIR = path.join(PROJECT_DIR, '.claude');
+const MEMORY_FILE = path.join(CLAUDE_DIR, 'MEMORY.md');
+const SESSION_STATE_FILE = path.join(CLAUDE_DIR, '.session-state.json');
+const SESSIONS_DIR = path.join(CLAUDE_DIR, 'sessions');
+const STATE_FILE = path.join(PROJECT_DIR, 'development', 'todos', '.state.json');
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || 'unknown';
+
+/**
+ * Ensure directories exist
+ */
+function ensureDirectories() {
+  [CLAUDE_DIR, SESSIONS_DIR].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+}
+
+/**
+ * Load session state from SessionStart
+ */
+function loadSessionState() {
+  if (!fs.existsSync(SESSION_STATE_FILE)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(SESSION_STATE_FILE, 'utf-8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Calculate session duration
+ */
+function calculateDuration(startTime) {
+  if (!startTime) return 'unknown';
+
+  const start = new Date(startTime);
+  const now = new Date();
+  const diffMs = now - start;
+  const diffMins = Math.floor(diffMs / 60000);
+
+  if (diffMins < 1) return 'less than 1 minute';
+  if (diffMins < 60) return `${diffMins} minutes`;
+
+  const hours = Math.floor(diffMins / 60);
+  const mins = diffMins % 60;
+  return `${hours}h ${mins}m`;
+}
+
+/**
+ * Save session summary to MEMORY.md
+ */
+function saveToMemory(sessionState) {
+  ensureDirectories();
+
+  const now = new Date();
+  const dateStr = now.toISOString().split('T')[0];
+  const duration = sessionState?.session?.startTime
+    ? calculateDuration(sessionState.session.startTime)
+    : 'unknown';
+
+  // Generate session entry
+  const entry = `### Session ${now.toISOString()}
+
+- **Duration**: ${duration}
+- **Project**: ${sessionState?.session?.project || 'unknown'}
+- **Memory entries**: ${sessionState?.memory?.entries || 0}
+- **TODOs**: ${sessionState?.todos?.active || 0} active, ${sessionState?.todos?.completed || 0} completed
+
+`;
+
+  // Read existing memory
+  let content = '';
+  if (fs.existsSync(MEMORY_FILE)) {
+    content = fs.readFileSync(MEMORY_FILE, 'utf-8');
+  }
+
+  // Check if today's section exists
+  const todaySection = `## ${dateStr}`;
+  if (content.includes(todaySection)) {
+    // Append to today's section
+    const parts = content.split(todaySection);
+    const beforeToday = parts[0];
+    const afterHeader = parts[1];
+
+    // Find next section or end
+    const nextSectionMatch = afterHeader.match(/\n## \d{4}-\d{2}-\d{2}/);
+    if (nextSectionMatch) {
+      const insertPoint = nextSectionMatch.index;
+      const todayContent = afterHeader.slice(0, insertPoint);
+      const restContent = afterHeader.slice(insertPoint);
+      content = beforeToday + todaySection + todayContent + entry + restContent;
+    } else {
+      content = beforeToday + todaySection + afterHeader + entry;
+    }
+  } else {
+    // Create new day section at the top
+    const header = content.startsWith('#') ? '' : '# Memory\n\n<!-- Project memory updated by AI -->\n\n';
+    const existingContent = content.replace(/^# Memory\n+(?:<!-- [^>]+ -->\n+)?/, '');
+    content = header + `${todaySection}\n\n${entry}` + existingContent;
+  }
+
+  // Keep only last 7 days
+  const sections = content.split(/(?=\n## \d{4}-\d{2}-\d{2})/);
+  const header = sections[0];
+  const daySections = sections.slice(1, 8); // Keep 7 days max
+  content = header + daySections.join('');
+
+  fs.writeFileSync(MEMORY_FILE, content.trim() + '\n');
+}
+
+/**
+ * Archive session state
+ */
+function archiveSession(sessionState) {
+  ensureDirectories();
+
+  const now = new Date();
+  const filename = `session_${now.toISOString().replace(/[:.]/g, '-')}.json`;
+  const filepath = path.join(SESSIONS_DIR, filename);
+
+  const archiveData = {
+    ...sessionState,
+    endTime: now.toISOString(),
+    duration: sessionState?.session?.startTime
+      ? calculateDuration(sessionState.session.startTime)
+      : 'unknown'
+  };
+
+  fs.writeFileSync(filepath, JSON.stringify(archiveData, null, 2));
+
+  // Clean up old sessions (keep last 20)
+  const files = fs.readdirSync(SESSIONS_DIR)
+    .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+    .sort()
+    .reverse();
+
+  if (files.length > 20) {
+    files.slice(20).forEach(f => {
+      try {
+        fs.unlinkSync(path.join(SESSIONS_DIR, f));
+      } catch (e) {
+        // Ignore deletion errors
+      }
+    });
+  }
+
+  return filename;
+}
+
+/**
+ * Update TODO state sync timestamp
+ */
+function syncTodoState() {
+  if (!fs.existsSync(STATE_FILE)) {
+    return;
+  }
+
+  try {
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    state.lastSynced = new Date().toISOString();
+    state.sessionId = SESSION_ID;
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {
+    // Ignore sync errors
+  }
+}
+
+/**
+ * Clean up session state file
+ */
+function cleanupSessionState() {
+  if (fs.existsSync(SESSION_STATE_FILE)) {
+    try {
+      fs.unlinkSync(SESSION_STATE_FILE);
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Format session end summary
+ */
+function formatEndSummary(sessionState, archiveFile) {
+  let summary = '';
+
+  const duration = sessionState?.session?.startTime
+    ? calculateDuration(sessionState.session.startTime)
+    : 'unknown';
+
+  summary += `\n✅ Session ended (${duration})\n`;
+  summary += `💾 Memory saved to MEMORY.md\n`;
+  summary += `📁 Archived: ${archiveFile}\n`;
+
+  return summary;
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  try {
+    const sessionState = loadSessionState();
+
+    if (sessionState) {
+      // Save to memory
+      saveToMemory(sessionState);
+
+      // Archive session
+      const archiveFile = archiveSession(sessionState);
+
+      // Sync TODO state
+      syncTodoState();
+
+      // Output summary
+      console.log(formatEndSummary(sessionState, archiveFile));
+    }
+
+    // Clean up
+    cleanupSessionState();
+
+    process.exit(0);
+  } catch (e) {
+    // Silent failure - don't interrupt session end
+    cleanupSessionState();
+    process.exit(0);
+  }
+}
+
+// Run
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  loadSessionState,
+  saveToMemory,
+  archiveSession,
+  syncTodoState,
+  calculateDuration,
+  formatEndSummary
+};

package/template/.claude/settings.json

@@ -1,4 +1,44 @@
 {
+  "env": {
+    "ENABLE_TOOL_SEARCH": "true",
+    "DISABLE_AUTOUPDATER": "1"
+  },
+  "SessionStart": [
+    {
+      "matcher": {},
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/memory-loader.cjs",
+          "timeout": 2000
+        }
+      ]
+    }
+  ],
+  "SessionEnd": [
+    {
+      "matcher": {},
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/memory-saver.cjs",
+          "timeout": 3000
+        }
+      ]
+    }
+  ],
+  "PreCompact": [
+    {
+      "matcher": {},
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/auto-handoff.cjs",
+          "timeout": 5000
+        }
+      ]
+    }
+  ],
   "UserPromptSubmit": [
     {
       "matcher": {},