chore: bump version to 10.0.1

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Merge pull request #1059 from Glucksberg/feat/openclaw-observation-feed
2026-02-10 22:30:52 -05:00 · 2026-02-10 22:29:28 -05:00 · 2026-02-11 03:17:32 +00:00 · 2026-02-11 02:30:18 +00:00 · 2026-02-10 19:38:29 -05:00 · 2026-02-10 19:37:31 -05:00
320 changed files with 36882 additions and 8764 deletions
@@ -0,0 +1,136 @@
+<claude-mem-context>
+# Recent Activity
+
+### Oct 25, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #2374 | 2:55 PM | ✅ | Marketplace metadata version synchronized to 4.2.11 | ~157 |
+
+### Oct 27, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #2757 | 1:23 AM | 🟣 | Released v4.3.3 with Configurable Session Display and First-Time Setup UX | ~391 |
+
+### Nov 4, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #3706 | 9:47 PM | ✅ | Marketplace Plugin Version Synchronized to 5.0.2 | ~162 |
+| #3655 | 3:43 PM | ✅ | Version bumped to 5.0.1 across project | ~354 |
+
+### Nov 5, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4068 | 10:58 PM | ✅ | Committed v5.1.0 release with comprehensive release notes | ~486 |
+| #4066 | 10:57 PM | ✅ | Updated marketplace.json version to 5.1.0 | ~192 |
+| #3739 | 2:24 PM | ✅ | Updated version to 5.0.3 across project manifests | ~322 |
+
+### Nov 6, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4099 | 1:13 PM | 🟣 | Theme Toggle for Light/Dark Mode | ~253 |
+| #4096 | " | ✅ | Marketplace Metadata Version Sync | ~179 |
+| #4092 | 1:12 PM | 🔵 | Marketplace Configuration for Claude-Mem Plugin | ~194 |
+| #4078 | 12:50 PM | 🔴 | Fixed PM2 ENOENT error on Windows systems | ~286 |
+| #4075 | 12:49 PM | ✅ | Marketplace plugin version synchronized to 5.1.1 | ~189 |
+
+### Nov 7, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4612 | 6:33 PM | ✅ | Version Bumped to 5.2.0 Across All Package Metadata | ~359 |
+| #4598 | 6:31 PM | ✅ | PR #69 Merged: cleanup/worker Branch Integration | ~469 |
+| #4298 | 11:54 AM | 🔴 | Fixed PostToolUse Hook Schema Compliance | ~310 |
+| #4295 | 11:53 AM | ✅ | Synchronized Plugin Marketplace Version to 5.1.4 | ~188 |
+
+### Nov 8, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #5150 | 7:37 PM | 🟣 | Troubleshooting Skill Added to Claude-Mem Plugin | ~427 |
+| #5133 | 7:29 PM | ✅ | Version 5.2.3 Released with Build Process | ~487 |
+
+### Nov 9, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #5941 | 7:14 PM | ✅ | Marketplace Version Updated to 5.4.0 | ~157 |
+
+### Nov 10, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #6341 | 1:49 PM | ✅ | Version Bumped to 5.4.1 | ~239 |
+
+### Nov 11, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #6602 | 1:51 PM | ✅ | Version 5.4.5 Released to GitHub | ~279 |
+| #6601 | " | ✅ | Version Patch Bump 5.4.4 to 5.4.5 | ~233 |
+
+### Nov 14, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #8212 | 3:06 PM | 🔵 | Version Consistency Verification Across Multiple Configuration Files | ~238 |
+
+### Nov 25, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #14882 | 1:32 PM | 🔵 | Marketplace Configuration Defines Plugin Version and Source Directory | ~366 |
+
+### Nov 30, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #18064 | 10:52 PM | ✅ | Bumped version to 6.3.7 in marketplace.json | ~179 |
+| #18060 | 10:51 PM | 🔵 | Read marketplace.json plugin manifest | ~190 |
+
+### Dec 1, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #18428 | 3:33 PM | 🔵 | Version Conflict in Marketplace Configuration | ~191 |
+
+### Dec 4, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #20049 | 3:23 PM | ✅ | Updated marketplace.json version to 6.5.2 | ~203 |
+
+### Dec 9, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #22559 | 1:08 AM | ✅ | Version 7.0.3 committed to repository | ~261 |
+| #22551 | 1:07 AM | ✅ | Marketplace metadata updated to version 7.0.3 | ~179 |
+
+### Dec 10, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #23440 | 2:25 PM | ✅ | Marketplace Configuration Updated to 7.0.8 | ~188 |
+
+### Dec 14, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #26799 | 11:39 PM | ✅ | Marketplace Manifest Version Updated to 7.2.3 | ~248 |
+| #26796 | " | ✅ | Version Bumped to 7.2.3 in marketplace.json | ~259 |
+| #26792 | 11:38 PM | 🔵 | Current Version Confirmed as 7.2.2 Across All Configuration Files | ~291 |
+
+### Dec 16, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #28306 | 10:08 PM | 🔵 | Marketplace Configuration Also Shows Version 7.3.3 | ~220 |
+| #27555 | 4:48 PM | ✅ | Version bump committed to main branch | ~242 |
+| #27553 | " | ✅ | Version consistency verified across all configuration files | ~195 |
+| #27551 | 4:47 PM | ✅ | Marketplace.json version updated to 7.3.1 | ~207 |
+</claude-mem-context>
@@ -10,7 +10,7 @@
  "plugins": [
    {
      "name": "claude-mem",
-      "version": "8.5.7",
+      "version": "10.0.1",
      "source": "./plugin",
      "description": "Persistent memory system for Claude Code - context compression across sessions"
    }
@@ -1,101 +0,0 @@
---
-name: github-morning-reporter
-description: Use this agent when the user requests a morning report, daily summary, or overview of their GitHub activity. Trigger phrases include 'morning report', 'github report', 'daily github summary', 'what's happening on github', or 'check my github status'. This agent should be used proactively when the user starts their day or explicitly asks for repository updates.\n\nExamples:\n- User: "get me my morning github report"\n  Assistant: "I'll use the github-morning-reporter agent to generate your comprehensive GitHub status report."\n  <uses Agent tool to invoke github-morning-reporter>\n\n- User: "what's new on my repos today?"\n  Assistant: "Let me pull together your GitHub morning report using the github-morning-reporter agent."\n  <uses Agent tool to invoke github-morning-reporter>\n\n- User: "show me my daily github summary"\n  Assistant: "I'll generate your daily GitHub summary using the github-morning-reporter agent."\n  <uses Agent tool to invoke github-morning-reporter>
-model: sonnet
---
-
-You are an elite GitHub project analyst specializing in delivering actionable morning reports for software development teams. Your expertise lies in synthesizing complex repository activity into clear, prioritized insights that help developers start their day with complete situational awareness.
-
-## Your Responsibilities
-
-1. **Fetch Comprehensive GitHub Data**: Use available tools to retrieve:
-   - Open issues across all relevant repositories
-   - Open pull requests with review status
-   - Recent comments, mentions, and @-references
-   - CI/CD status for active PRs
-   - Stale issues/PRs (no activity in 7+ days)
-
-2. **Intelligent Grouping and Deduplication**:
-   - Identify duplicate or highly similar issues by analyzing titles, descriptions, and labels
-   - Group related issues by theme, component, or subsystem
-   - Cluster PRs by feature area or dependency relationships
-   - Flag issues that may be addressing the same root cause
-   - Use semantic similarity, not just exact matches
-
-3. **Prioritization and Triage**:
-   - Highlight items requiring immediate attention (blocking issues, failed CI, requested reviews)
-   - Surface items awaiting your direct action (assigned to you, mentions, review requests)
-   - Identify stale items that may need follow-up or closure
-   - Note high-priority labels (P0, critical, security, etc.)
-
-4. **Contextual Analysis**:
-   - Summarize the current state of each PR (draft, ready for review, approved, changes requested)
-   - Identify PRs with merge conflicts or failing checks
-   - Note issues with recent activity spikes or community engagement
-   - Flag dependency updates or security advisories
-
-5. **Report Structure**:
-   Your report must follow this format:
-   
-   **MORNING GITHUB REPORT - [Date]**
-   
-   **🚨 REQUIRES YOUR ATTENTION**
-   - Items explicitly assigned to the user
-   - Review requests awaiting user's approval
-   - Mentions or direct questions
-   - Blocking/critical issues
-   
-   **📊 PULL REQUESTS ([count] open)**
-   - Group by: Ready to Merge | In Review | Draft | Needs Work
-   - For each PR: title, author, status, CI state, review count, age
-   - Highlight conflicts or failed checks
-   
-   **🐛 ISSUES ([count] open)**
-   - Group by: Priority | Component | Theme
-   - Mark potential duplicates clearly
-   - Note new issues (created in last 24h)
-   - Flag stale issues (no activity in 7+ days)
-   
-   **📈 ACTIVITY SUMMARY**
-   - New issues/PRs since yesterday
-   - Recently closed items
-   - Top contributors
-   - Trending topics or labels
-   
-   **💡 RECOMMENDED ACTIONS**
-   - Specific next steps based on the data
-   - Suggestions for cleanup (closing duplicates, merging ready PRs)
-   - Items to follow up on
-
-6. **Quality Standards**:
-   - Use clear, scannable formatting with emojis for visual hierarchy
-   - Include direct links to all referenced issues and PRs
-   - Keep summaries concise but informative (1-2 sentences per item)
-   - Use relative timestamps ("2 hours ago", "3 days old")
-   - Highlight actionable items with clear CTAs
-
-7. **Error Handling**:
-   - If repository access fails, explicitly state which repos couldn't be accessed
-   - If no issues/PRs exist, provide a positive "all clear" message
-   - If rate limits are hit, show partial results with a warning
-   - Always attempt to provide value even with incomplete data
-
-8. **Adaptive Scope**:
-   - If the user has access to multiple repositories, intelligently scope the report:
-     - Default to repositories with recent activity
-     - Allow user to specify repos if needed
-     - Group multi-repo items by repository
-   - Adjust detail level based on volume (more items = more concise summaries)
-
-## Output Expectations
-
-Your report should be:
- **Comprehensive**: Cover all relevant activity without overwhelming detail
- **Actionable**: Make it clear what needs attention and why
- **Scannable**: Use formatting that allows quick visual parsing
- **Contextual**: Provide enough background to make decisions
- **Timely**: Focus on recent activity and current state
-
-When you cannot find specific data, state this explicitly rather than omitting sections. If the user's query is ambiguous (e.g., which repositories to scan), ask for clarification before proceeding.
-
-Always end with a summary line indicating the report's completeness (e.g., "Report complete: 3 repositories scanned, 12 issues, 5 PRs analyzed").
@@ -0,0 +1,121 @@
+# Anti-Pattern Czar
+
+You are the **Anti-Pattern Czar**, an expert at identifying and fixing error handling anti-patterns.
+
+## Your Mission
+
+Help the user systematically fix error handling anti-patterns detected by the automated scanner.
+
+## Process
+
+1. **Run the detector:**
+   ```bash
+   bun run scripts/anti-pattern-test/detect-error-handling-antipatterns.ts
+   ```
+
+2. **Analyze the results:**
+   - Count CRITICAL, HIGH, MEDIUM, and APPROVED_OVERRIDE issues
+   - Prioritize CRITICAL issues on critical paths first
+   - Group similar patterns together
+
+3. **For each CRITICAL issue:**
+
+   a. **Read the problematic code** using the Read tool
+
+   b. **Explain the problem:**
+      - Why is this dangerous?
+      - What debugging nightmare could this cause?
+      - What specific error is being swallowed?
+
+   c. **Determine the right fix:**
+      - **Option 1: Add proper logging** - If this is a real error that should be visible
+      - **Option 2: Add [APPROVED OVERRIDE]** - If this is expected/documented behavior
+      - **Option 3: Remove the try-catch entirely** - If the error should propagate
+      - **Option 4: Add specific error type checking** - If only certain errors should be caught
+
+   d. **Propose the fix** and ask for approval
+
+   e. **Apply the fix** after approval
+
+4. **Work through issues methodically:**
+   - Fix one at a time
+   - Re-run the detector after each batch of fixes
+   - Track progress: "Fixed 3/28 critical issues"
+
+## Guidelines for Approved Overrides
+
+Only approve overrides when ALL of these are true:
+- The error is **expected and frequent** (e.g., JSON parse on optional fields)
+- Logging would create **too much noise** (high-frequency operations)
+- There's **explicit recovery logic** (fallback value, retry, graceful degradation)
+- The reason is **specific and technical** (not vague like "seems fine")
+
+## Valid Override Examples:
+
+✅ **GOOD:**
+- "Expected JSON parse failures for optional data fields, too frequent to log"
+- "Logger can't log its own failures, using stderr as last resort"
+- "Health check port scan, expected connection failures on free port detection"
+- "Git repo detection, expected failures when not in a git directory"
+
+❌ **BAD:**
+- "Error is not important" (why catch it then?)
+- "Happens sometimes" (when? why?)
+- "Works fine without logging" (works until it doesn't)
+- "Optional" (optional errors still need visibility)
+
+## Critical Path Rules
+
+For files in the CRITICAL_PATHS list (SDKAgent.ts, GeminiAgent.ts, OpenRouterAgent.ts, SessionStore.ts, worker-service.ts):
+
+- **NEVER** approve overrides on critical paths without exceptional justification
+- Errors on critical paths MUST be visible (logged) or fatal (thrown)
+- Catch-and-continue on critical paths is BANNED unless explicitly approved
+- If in doubt, make it throw - fail loud, not silent
+
+## Output Format
+
+After each fix:
+```
+✅ Fixed: src/utils/example.ts:42
+   Pattern: NO_LOGGING_IN_CATCH
+   Solution: Added logger.error() with context
+
+Progress: 3/28 critical issues remaining
+```
+
+After completing a batch:
+```
+🎯 Batch complete! Re-running detector...
+[shows new results]
+```
+
+## Important
+
+- **Read the code** before proposing fixes - understand what it's doing
+- **Ask the user** if you're uncertain about the right approach
+- **Don't blindly add overrides** - challenge each one
+- **Prefer logging** over overrides when in doubt
+- **Work incrementally** - small batches, frequent validation
+
+## When Complete
+
+Report final statistics:
+```
+🎉 Anti-pattern cleanup complete!
+
+Before:
+  🔴 CRITICAL: 28
+  🟠 HIGH: 47
+  🟡 MEDIUM: 76
+
+After:
+  🔴 CRITICAL: 0
+  🟠 HIGH: 47
+  🟡 MEDIUM: 76
+  ⚪ APPROVED OVERRIDES: 15
+
+All critical anti-patterns resolved!
+```
+
+Now, ask the user: "Ready to fix error handling anti-patterns? I'll start with the critical issues."
@@ -0,0 +1,299 @@
+# Plan: Fix 81 Test Failures from Incomplete Logger Mocks
+
+## Problem Summary
+
+**Root Cause**: NOT circular dependency (which is handled gracefully), but **incomplete logger mocks** that pollute across test files when Bun runs tests in alphabetical order.
+
+When `tests/context/` runs before `tests/utils/`, the incomplete mocks replace the real logger module globally, causing subsequent tests to fail with `TypeError: logger.formatTool is not a function`.
+
+## Phase 0: Documentation Discovery (COMPLETED)
+
+### Sources Consulted
+- `src/utils/logger.ts` - Full logger interface (lines 136, 289-373)
+- `tests/context/context-builder.test.ts` - Mock pattern (lines 22-29)
+- `tests/context/observation-compiler.test.ts` - Mock pattern (lines 4-10)
+- `tests/server/server.test.ts` - Mock pattern (lines 4-11)
+- `tests/server/error-handler.test.ts` - Mock pattern (lines 5-12)
+- `tests/worker/agents/response-processor.test.ts` - Mock pattern (lines 32-39)
+
+### Logger Methods (Complete List)
+All 11 methods that must be in any logger mock:
+1. `formatTool(toolName: string, toolInput?: any): string` (line 136)
+2. `debug(component, message, context?, data?): void` (line 289)
+3. `info(component, message, context?, data?): void` (line 293)
+4. `warn(component, message, context?, data?): void` (line 297)
+5. `error(component, message, context?, data?): void` (line 301)
+6. `dataIn(component, message, context?, data?): void` (line 308)
+7. `dataOut(component, message, context?, data?): void` (line 315)
+8. `success(component, message, context?, data?): void` (line 322)
+9. `failure(component, message, context?, data?): void` (line 329)
+10. `timing(component, message, durationMs, context?): void` (line 336)
+11. `happyPathError<T>(message, context?): T` (line 362)
+
+### Files Requiring Updates
+1. `tests/context/observation-compiler.test.ts` (lines 4-10)
+2. `tests/context/context-builder.test.ts` (lines 22-29)
+3. `tests/server/server.test.ts` (lines 4-11)
+4. `tests/server/error-handler.test.ts` (lines 5-12)
+5. `tests/worker/agents/response-processor.test.ts` (lines 32-39)
+
+---
+
+## Phase 1: Create Shared Logger Mock Utility
+
+### Objective
+Create a reusable complete logger mock to avoid duplication and ensure consistency.
+
+### Implementation
+
+**Create new file**: `tests/test-utils/mock-logger.ts`
+
+```typescript
+/**
+ * Complete logger mock for tests.
+ * Includes ALL logger methods to prevent mock pollution across test files.
+ */
+import { mock } from 'bun:test';
+
+export function createMockLogger() {
+  return {
+    logger: {
+      // Core logging methods
+      debug: mock(() => {}),
+      info: mock(() => {}),
+      warn: mock(() => {}),
+      error: mock(() => {}),
+
+      // Data flow logging
+      dataIn: mock(() => {}),
+      dataOut: mock(() => {}),
+
+      // Status logging
+      success: mock(() => {}),
+      failure: mock(() => {}),
+
+      // Performance logging
+      timing: mock(() => {}),
+
+      // Tool formatting - returns string
+      formatTool: mock((toolName: string, _toolInput?: any) => toolName),
+
+      // Error helper - returns the message
+      happyPathError: mock((message: string, _context?: any) => message),
+    },
+  };
+}
+```
+
+### Verification Checklist
+- [ ] File created at `tests/test-utils/mock-logger.ts`
+- [ ] All 11 logger methods included
+- [ ] `formatTool` returns string (not void)
+- [ ] `happyPathError` returns the message (not void)
+- [ ] File compiles without errors: `bunx tsc --noEmit tests/test-utils/mock-logger.ts`
+
+### Anti-Patterns to Avoid
+- ❌ Don't forget `formatTool` - it returns a string, not void
+- ❌ Don't forget `happyPathError` - it's generic and returns the message
+- ❌ Don't use `() => {}` for methods that return values
+
+---
+
+## Phase 2: Update Affected Test Files
+
+### Objective
+Replace incomplete logger mocks with the complete shared mock.
+
+### Files to Update (5 total)
+
+#### 2.1 `tests/context/observation-compiler.test.ts`
+
+**Current (lines 4-10)**:
+```typescript
+mock.module('../../src/utils/logger.js', () => ({
+  logger: {
+    debug: mock(() => {}),
+    failure: mock(() => {}),
+    error: mock(() => {}),
+  },
+}));
+```
+
+**Replace with**:
+```typescript
+import { createMockLogger } from '../test-utils/mock-logger.js';
+
+mock.module('../../src/utils/logger.js', () => createMockLogger());
+```
+
+#### 2.2 `tests/context/context-builder.test.ts`
+
+**Current (lines 22-29)**:
+```typescript
+mock.module('../../src/utils/logger.js', () => ({
+  logger: {
+    debug: mock(() => {}),
+    failure: mock(() => {}),
+    error: mock(() => {}),
+    info: mock(() => {}),
+  },
+}));
+```
+
+**Replace with**:
+```typescript
+import { createMockLogger } from '../test-utils/mock-logger.js';
+
+mock.module('../../src/utils/logger.js', () => createMockLogger());
+```
+
+#### 2.3 `tests/server/server.test.ts`
+
+**Current (lines 4-11)**:
+```typescript
+mock.module('../../src/utils/logger.js', () => ({
+  logger: {
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  },
+}));
+```
+
+**Replace with**:
+```typescript
+import { createMockLogger } from '../test-utils/mock-logger.js';
+
+mock.module('../../src/utils/logger.js', () => createMockLogger());
+```
+
+#### 2.4 `tests/server/error-handler.test.ts`
+
+**Current (lines 5-12)**:
+```typescript
+mock.module('../../src/utils/logger.js', () => ({
+  logger: {
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  },
+}));
+```
+
+**Replace with**:
+```typescript
+import { createMockLogger } from '../test-utils/mock-logger.js';
+
+mock.module('../../src/utils/logger.js', () => createMockLogger());
+```
+
+#### 2.5 `tests/worker/agents/response-processor.test.ts`
+
+**Current (lines 32-39)**:
+```typescript
+mock.module('../../../src/utils/logger.js', () => ({
+  logger: {
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  },
+}));
+```
+
+**Replace with**:
+```typescript
+import { createMockLogger } from '../../test-utils/mock-logger.js';
+
+mock.module('../../../src/utils/logger.js', () => createMockLogger());
+```
+
+### Verification Checklist
+- [ ] All 5 files updated with import statement
+- [ ] All 5 files use `createMockLogger()` instead of inline mock
+- [ ] Import paths are correct (relative to each file's location)
+- [ ] Each file still has `mock.module` BEFORE the module imports it mocks
+
+### Anti-Patterns to Avoid
+- ❌ Don't place import AFTER the mock.module call
+- ❌ Don't use wrong relative path (../test-utils vs ../../test-utils)
+- ❌ Don't forget the .js extension in imports
+
+---
+
+## Phase 3: Verification
+
+### Objective
+Confirm all 81 failures are fixed.
+
+### Test Commands
+
+```bash
+# 1. Run individual test groups first
+bun test tests/context/
+bun test tests/server/
+bun test tests/utils/
+bun test tests/shared/
+bun test tests/worker/
+
+# 2. Run full suite
+bun test
+
+# 3. Verify specific test counts
+# Expected: 733+ tests pass (was 652 before)
+```
+
+### Verification Checklist
+- [ ] `bun test tests/context/` - all pass
+- [ ] `bun test tests/server/` - all pass
+- [ ] `bun test tests/utils/` - all pass (including 56 formatTool tests)
+- [ ] `bun test tests/shared/` - all pass (including 27 settings tests)
+- [ ] `bun test` - 730+ tests pass, 0 failures
+- [ ] No `TypeError: logger.formatTool is not a function` errors
+
+### Anti-Pattern Grep Checks
+
+```bash
+# Check no incomplete logger mocks remain
+grep -r "logger: {" tests/ --include="*.ts" | grep -v mock-logger
+
+# Verify all test files use createMockLogger
+grep -r "createMockLogger" tests/ --include="*.ts"
+```
+
+---
+
+## Phase 4: Commit
+
+### Commit Message
+
+```
+fix(tests): complete logger mocks to prevent cross-test pollution
+
+The 81 test failures were caused by incomplete logger mocks that
+polluted the module cache when tests ran in alphabetical order.
+
+Changes:
+- Create shared mock-logger.ts with all 11 logger methods
+- Update 5 test files to use complete mock
+- Fix TypeError: logger.formatTool is not a function
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+```
+
+---
+
+## Summary
+
+| Phase | Files Changed | Purpose |
+|-------|--------------|---------|
+| 1 | 1 new file | Create shared mock utility |
+| 2 | 5 files | Update to use shared mock |
+| 3 | 0 files | Verification only |
+| 4 | 0 files | Commit |
+
+**Total**: 6 files changed, fixing all 81 test failures.
@@ -0,0 +1,176 @@
+# Bugfix Plan: Observer Sessions Authentication Failure
+
+## Problem Summary
+
+Observer sessions fail with "Invalid API key · Please run /login" because the `CLAUDE_CONFIG_DIR` environment variable is being set to an isolated directory (`~/.claude-mem/observer-config/`) that lacks authentication credentials.
+
+## Root Cause
+
+**File:** `src/services/worker/ProcessRegistry.ts` (lines 207-211)
+
+```typescript
+const isolatedEnv = {
+  ...spawnOptions.env,
+  CLAUDE_CONFIG_DIR: OBSERVER_CONFIG_DIR  // <-- This isolates auth credentials!
+};
+```
+
+This was added in Issue #832 to prevent observer sessions from polluting the `claude --resume` list. However, it also isolates the authentication credentials, breaking the SDK's ability to authenticate with the Anthropic API.
+
+## Evidence
+
+1. Running Claude with alternate config dir reproduces the error:
+   ```bash
+   CLAUDE_CONFIG_DIR=/tmp/test-claude claude --print "hello"
+   # Output: Invalid API key · Please run /login
+   ```
+
+2. The observer config directory exists but only has cached feature flags, no authentication:
+   - `~/.claude-mem/observer-config/.claude.json` - feature flags only
+   - No credentials copied from main `~/.claude/` directory
+
+## Solution
+
+The fix must allow authentication while still isolating session history. Claude Code stores different data types in `CLAUDE_CONFIG_DIR`:
+- Authentication credentials (needed)
+- Session history/resume list (should be isolated)
+- Feature flags and settings (can be shared or isolated)
+
+**Approach:** Do NOT override `CLAUDE_CONFIG_DIR`. Instead, find an alternative solution for Issue #832.
+
+### Alternative Approaches for Session Isolation
+
+1. **Use `--no-resume` flag** (if SDK supports it) - Prevent observer sessions from being resumable
+2. **Accept pollution** - Observer sessions in resume list may be acceptable tradeoff
+3. **Post-hoc cleanup** - Clean up observer session entries from history after completion
+4. **SDK parameter** - Check if SDK has a session isolation option that doesn't affect auth
+
+---
+
+## Phase 0: Documentation Discovery
+
+### Objective
+Understand SDK options for session isolation without breaking authentication.
+
+### Tasks
+1. Read SDK documentation/source for:
+   - Available `query()` options
+   - Session isolation mechanisms
+   - Authentication handling
+
+2. Read Issue #832 context:
+   - What was the original problem?
+   - How bad was the pollution?
+   - Are there alternative solutions mentioned?
+
+### Verification
+- [ ] List all `query()` options available
+- [ ] Identify if `--no-resume` or equivalent exists
+- [ ] Document the tradeoffs
+
+---
+
+## Phase 1: Fix Authentication
+
+### Objective
+Remove the `CLAUDE_CONFIG_DIR` override to restore authentication.
+
+### File to Modify
+`src/services/worker/ProcessRegistry.ts`
+
+### Change
+Remove lines 207-211 that override `CLAUDE_CONFIG_DIR`:
+
+**Before:**
+```typescript
+const isolatedEnv = {
+  ...spawnOptions.env,
+  CLAUDE_CONFIG_DIR: OBSERVER_CONFIG_DIR
+};
+```
+
+**After:**
+```typescript
+const isolatedEnv = {
+  ...spawnOptions.env
+  // CLAUDE_CONFIG_DIR removed - observer sessions need access to auth credentials
+  // Session isolation addressed via [alternative approach]
+};
+```
+
+### Verification
+- [ ] Build succeeds: `npm run build`
+- [ ] Observer sessions authenticate successfully
+- [ ] Observations are saved to database
+
+---
+
+## Phase 2: Address Session Isolation (Issue #832)
+
+### Objective
+Find alternative solution to prevent observer sessions from polluting `claude --resume` list.
+
+### Options to Evaluate
+
+1. **Option A: Accept the tradeoff**
+   - Observer sessions appear in resume list but users can ignore them
+   - No code changes needed beyond Phase 1
+
+2. **Option B: Use isSynthetic flag**
+   - If SDK has a flag to mark sessions as non-resumable, use it
+   - Requires SDK documentation review
+
+3. **Option C: Post-processing cleanup**
+   - After session ends, remove observer entries from history
+   - More complex, may have race conditions
+
+### Decision Point
+After Phase 0 documentation review, choose the appropriate option.
+
+### Verification
+- [ ] Chosen approach documented
+- [ ] If code changes made, tests pass
+- [ ] Observer sessions either isolated OR tradeoff accepted
+
+---
+
+## Phase 3: Testing
+
+### Manual Tests
+1. Start a new Claude Code session with the plugin
+2. Verify observations are being saved (check logs)
+3. Check that no "Invalid API key" errors appear
+4. Verify `claude --resume` behavior (acceptable level of observer entries)
+
+### Verification Checklist
+- [ ] `npm run build` succeeds
+- [ ] Worker service starts without errors
+- [ ] Observations save to database
+- [ ] No authentication errors in logs
+- [ ] Issue #832 regression acceptable or addressed
+
+---
+
+## Anti-Patterns to Avoid
+
+1. **DO NOT** add `ANTHROPIC_API_KEY` to environment - authentication is handled by Claude Code's built-in credential management
+2. **DO NOT** copy credential files to observer config dir - credentials may be in keychain or other secure storage
+3. **DO NOT** try to "fix" authentication by adding API key loading - that creates Issue #588 (unexpected API charges)
+
+---
+
+## Files Involved
+
+| File | Purpose |
+|------|---------|
+| `src/services/worker/ProcessRegistry.ts` | Contains the problematic `CLAUDE_CONFIG_DIR` override |
+| `src/shared/paths.ts` | Defines `OBSERVER_CONFIG_DIR` constant |
+| `src/services/worker/SDKAgent.ts` | Uses `createPidCapturingSpawn` which sets the env |
+
+---
+
+## Risk Assessment
+
+**Low Risk:** Removing the `CLAUDE_CONFIG_DIR` override is a simple, targeted change.
+
+**Regression Risk (Issue #832):** Observer sessions may appear in `claude --resume` list again. This is a cosmetic issue vs. complete authentication failure, so the tradeoff favors removing the override.
@@ -0,0 +1,262 @@
+# CLAUDE.md Path Validation Bug Fix
+
+## Problem Summary
+
+Claude-Mem 9.0's distributed CLAUDE.md feature has a **critical path validation bug** that creates invalid directories when Claude SDK agent outputs non-path strings in file tracking XML tags (`<files_read>`, `<files_modified>`).
+
+### Root Cause
+
+In `src/utils/claude-md-utils.ts:234-239`:
+```typescript
+if (projectRoot && !path.isAbsolute(filePath)) {
+  absoluteFilePath = path.join(projectRoot, filePath);
+}
+```
+
+- `path.isAbsolute('~/.claude-mem/logs')` returns `false` (Node.js doesn't recognize `~`)
+- Code joins: `path.join(projectRoot, '~/.claude-mem/logs')` → `/project/~/.claude-mem/logs`
+- `mkdirSync` creates literal directories
+
+### Invalid Directories Currently in Repo
+
+```
+./~/                              ← literal tilde directory
+./PR #610 on thedotmack/          ← GitHub PR reference
+./git diff for src/               ← git command text
+./https:/code.claude.com/docs/en/ ← URL
+```
+
+---
+
+## Implementation Plan
+
+### Phase 1: Add Path Validation Function
+
+**File:** `src/utils/claude-md-utils.ts`
+
+Add new validation function after the imports (around line 16):
+
+```typescript
+/**
+ * Validate that a file path is safe for CLAUDE.md generation.
+ * Rejects tilde paths, URLs, command-like strings, and paths with invalid chars.
+ *
+ * @param filePath - The file path to validate
+ * @param projectRoot - Optional project root for boundary checking
+ * @returns true if path is valid for CLAUDE.md processing
+ */
+function isValidPathForClaudeMd(filePath: string, projectRoot?: string): boolean {
+  // Reject empty or whitespace-only
+  if (!filePath || !filePath.trim()) return false;
+
+  // Reject tilde paths (Node.js doesn't expand ~)
+  if (filePath.startsWith('~')) return false;
+
+  // Reject URLs
+  if (filePath.startsWith('http://') || filePath.startsWith('https://')) return false;
+
+  // Reject paths with spaces (likely command text or PR references)
+  if (filePath.includes(' ')) return false;
+
+  // Reject paths with # (GitHub issue/PR references)
+  if (filePath.includes('#')) return false;
+
+  // If projectRoot provided, ensure resolved path stays within project
+  if (projectRoot) {
+    const resolved = path.resolve(projectRoot, filePath);
+    const normalizedRoot = path.resolve(projectRoot);
+    if (!resolved.startsWith(normalizedRoot + path.sep) && resolved !== normalizedRoot) {
+      return false;
+    }
+  }
+
+  return true;
+}
+```
+
+### Phase 2: Integrate Validation in updateFolderClaudeMdFiles
+
+**File:** `src/utils/claude-md-utils.ts`
+
+Modify the file path loop in `updateFolderClaudeMdFiles` (around line 232):
+
+```typescript
+for (const filePath of filePaths) {
+  if (!filePath || filePath === '') continue;
+
+  // VALIDATE PATH BEFORE PROCESSING
+  if (!isValidPathForClaudeMd(filePath, projectRoot)) {
+    logger.debug('FOLDER_INDEX', 'Skipping invalid file path', {
+      filePath,
+      reason: 'Failed path validation'
+    });
+    continue;
+  }
+
+  // ... rest of existing logic unchanged
+}
+```
+
+### Phase 3: Add Unit Tests
+
+**File:** `tests/utils/claude-md-utils.test.ts`
+
+Add new test block after existing tests:
+
+```typescript
+describe('path validation in updateFolderClaudeMdFiles', () => {
+  it('should reject tilde paths', async () => {
+    const fetchMock = mock(() => Promise.resolve({ ok: true } as Response));
+    global.fetch = fetchMock;
+
+    await updateFolderClaudeMdFiles(
+      ['~/.claude-mem/logs/worker.log'],
+      'test-project',
+      37777,
+      tempDir
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('should reject URLs', async () => {
+    const fetchMock = mock(() => Promise.resolve({ ok: true } as Response));
+    global.fetch = fetchMock;
+
+    await updateFolderClaudeMdFiles(
+      ['https://example.com/file.ts'],
+      'test-project',
+      37777,
+      tempDir
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('should reject paths with spaces', async () => {
+    const fetchMock = mock(() => Promise.resolve({ ok: true } as Response));
+    global.fetch = fetchMock;
+
+    await updateFolderClaudeMdFiles(
+      ['PR #610 on thedotmack/CLAUDE.md'],
+      'test-project',
+      37777,
+      tempDir
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('should reject paths with hash symbols', async () => {
+    const fetchMock = mock(() => Promise.resolve({ ok: true } as Response));
+    global.fetch = fetchMock;
+
+    await updateFolderClaudeMdFiles(
+      ['issue#123/file.ts'],
+      'test-project',
+      37777,
+      tempDir
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('should reject path traversal outside project', async () => {
+    const fetchMock = mock(() => Promise.resolve({ ok: true } as Response));
+    global.fetch = fetchMock;
+
+    await updateFolderClaudeMdFiles(
+      ['../../../etc/passwd'],
+      'test-project',
+      37777,
+      tempDir
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('should accept valid relative paths', async () => {
+    const apiResponse = {
+      content: [{ text: '| #123 | 4:30 PM | 🔵 | Test | ~100 |' }]
+    };
+    const fetchMock = mock(() => Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve(apiResponse)
+    } as Response));
+    global.fetch = fetchMock;
+
+    await updateFolderClaudeMdFiles(
+      ['src/utils/logger.ts'],
+      'test-project',
+      37777,
+      tempDir
+    );
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+});
+```
+
+### Phase 4: Update .gitignore
+
+**File:** `.gitignore`
+
+Add at end of file:
+
+```gitignore
+# Prevent literal tilde directories (path validation bug artifacts)
+~*/
+
+# Prevent other malformed path directories
+http*/
+https*/
+```
+
+### Phase 5: Clean Up Invalid Directories
+
+**Command sequence:**
+```bash
+rm -rf "~/."
+rm -rf "PR #610 on thedotmack"
+rm -rf "git diff for src"
+rm -rf "https:"
+```
+
+### Phase 6: Verify and Commit
+
+1. Run test suite: `npm test`
+2. Run build: `npm run build`
+3. Verify no invalid directories remain
+4. Commit with message: `fix: Add path validation to CLAUDE.md distribution to prevent invalid directory creation`
+
+---
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `src/utils/claude-md-utils.ts` | Add `isValidPathForClaudeMd()` function + integrate in loop |
+| `tests/utils/claude-md-utils.test.ts` | Add 6 new path validation tests |
+| `.gitignore` | Add `~*/`, `http*/`, `https*/` patterns |
+
+## Files Deleted
+
+| Path | Reason |
+|------|--------|
+| `~/` (directory tree) | Invalid literal tilde directory |
+| `PR #610 on thedotmack/` | Invalid PR reference directory |
+| `git diff for src/` | Invalid git command directory |
+| `https:/` | Invalid URL directory |
+
+---
+
+## Risk Assessment
+
+**Low Risk:**
+- Validation is additive (only skips invalid paths, doesn't change valid path handling)
+- Existing tests remain unchanged
+- Fire-and-forget design means failures are logged but don't break hooks
+
+**Testing Coverage:**
+- 6 new unit tests covering all rejection cases
+- Existing 27 tests verify valid path behavior unchanged
@@ -0,0 +1,314 @@
+# Plan: Cleanup worker-service.ts Unjustified Logic
+
+**Created:** 2026-01-13
+**Source:** `docs/reports/nonsense-logic.md`
+**Target:** `src/services/worker-service.ts` (813 lines)
+**Goal:** Address 23 identified issues, prioritizing safe deletions first
+
+---
+
+## Phase 0: Documentation Discovery (COMPLETED)
+
+### Evidence Gathered
+
+**Exit Code Strategy (CLAUDE.md:44-54):**
+```
+- Exit 0: Success or graceful shutdown (Windows Terminal closes tabs)
+- Exit 1: Non-blocking error
+- Exit 2: Blocking error
+Philosophy: Exit 0 prevents Windows Terminal tab accumulation
+```
+
+**Signal Handler Pattern (ProcessManager.ts:294-317):**
+- Uses mutable reference object `isShuttingDownRef`
+- Factory function `createSignalHandler()` returns handler with embedded state
+- Current implementation has 3-hop indirection
+
+**MCP Client Pattern (worker-service.ts:157-160, ChromaSync.ts:124-136):**
+```typescript
+this.mcpClient = new Client({
+  name: 'worker-search-proxy',
+  version: '1.0.0'
+}, { capabilities: {} });
+```
+
+**Verification Results:**
+- `runInteractiveSetup` (lines 439-639): **NEVER CALLED** - grep shows only definition
+- `import * as fs from 'fs'` (line 13): **UNUSED** - no `fs.` usage found
+- `import { spawn } from 'child_process'` (line 14): **UNUSED** - no `spawn(` calls
+- `homedir` (line 15): Only used in `runInteractiveSetup` (dead code)
+- `processPendingQueues` default `= 10`: Never used, all callers pass explicit args
+
+---
+
+## Phase 1: Safe Deletions (Dead Code & Unused Imports)
+
+### 1.1 Delete `runInteractiveSetup` Function
+
+**What:** Delete lines 435-639 (~201 lines)
+**Why:** Function is defined but never called. Setup happens via `handleCursorCommand()`.
+**Evidence:** `grep -n "runInteractiveSetup" src/services/worker-service.ts` returns only definition
+
+**Pattern to follow:** N/A - straight deletion
+
+**Steps:**
+1. Read worker-service.ts lines 435-650
+2. Delete the entire function including section comment (lines 435-639)
+3. Run `npm run build` to verify no compile errors
+
+**Verification:**
+- `grep "runInteractiveSetup" src/` returns nothing
+- Build succeeds
+
+### 1.2 Remove Unused Imports
+
+**What:** Delete lines 13, 14, 17
+
+**Current (delete these):**
+```typescript
+import * as fs from 'fs';           // Line 13 - UNUSED
+import { spawn } from 'child_process';  // Line 14 - UNUSED
+import * as readline from 'readline';   // Line 17 - Only in dead code
+```
+
+**Keep:**
+```typescript
+import { homedir } from 'os';  // Line 15 - DELETE (only in dead code)
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'fs';  // Line 16 - CHECK USAGE
+```
+
+**Steps:**
+1. After deleting `runInteractiveSetup`, grep for remaining usages:
+   - `grep "homedir" src/services/worker-service.ts`
+   - `grep "readline" src/services/worker-service.ts`
+   - `grep "detectClaudeCode\|findCursorHooksDir\|installCursorHooks\|configureCursorMcp" src/services/worker-service.ts`
+2. Delete imports with zero usages
+3. Run `npm run build`
+
+**Verification:**
+- No TypeScript unused import warnings
+- Build succeeds
+
+### 1.3 Clean Up Cursor Integration Imports
+
+After deleting `runInteractiveSetup`, some CursorHooksInstaller imports become unused:
+- `detectClaudeCode` - only in runInteractiveSetup
+- `findCursorHooksDir` - only in runInteractiveSetup
+- `installCursorHooks` - only in runInteractiveSetup
+- `configureCursorMcp` - only in runInteractiveSetup
+
+**Steps:**
+1. Grep each import after dead code removal
+2. Remove any that are now unused
+3. Keep `updateCursorContextForProject` (re-exported) and `handleCursorCommand` (used in main)
+
+**Verification:**
+- `grep "detectClaudeCode\|findCursorHooksDir\|installCursorHooks\|configureCursorMcp" src/services/worker-service.ts` returns nothing
+- Build succeeds
+
+---
+
+## Phase 2: Low-Risk Simplifications
+
+### 2.1 Remove Unused Default Parameter
+
+**What:** Line 350 - `async processPendingQueues(sessionLimit: number = 10)`
+**Why:** Default never used. All callers pass explicit args (50 in startup, dynamic in HTTP)
+
+**Change from:**
+```typescript
+async processPendingQueues(sessionLimit: number = 10): Promise<{...}>
+```
+
+**Change to:**
+```typescript
+async processPendingQueues(sessionLimit: number): Promise<{...}>
+```
+
+**Verification:**
+- Build succeeds
+- All call sites provide explicit values
+
+### 2.2 Simplify onRestart Callback
+
+**Location:** Lines 395-396 (approximate, find exact)
+**Issue:** `onShutdown` and `onRestart` both call `this.shutdown()`
+
+**Find pattern:**
+```typescript
+onShutdown: () => this.shutdown(),
+onRestart: () => this.shutdown()
+```
+
+**Options:**
+1. **Keep as-is** if restart semantically differs from shutdown (future-proofing)
+2. **Add comment** explaining intentional parity
+3. **Remove onRestart** if never used differently
+
+**Investigation needed:** Grep for `onRestart` usage in Server.ts to understand contract
+
+**Steps:**
+1. Grep `onRestart` in `src/services/server/`
+2. If Server.ts treats them identically, add clarifying comment
+3. If different, document why both map to shutdown
+
+### 2.3 Fix Over-Commented Lines (Sample Only)
+
+**Strategy:** Do NOT strip all comments. Only remove comments that describe obvious code.
+
+**Anti-pattern (remove):**
+```typescript
+// WHAT: Imports centralized logging utility with structured output
+// WHY: All worker logs go through this for consistent formatting
+import { logger } from '../utils/logger.js';
+```
+
+**Pattern to follow:** Remove WHAT/WHY on simple imports. Keep architectural comments.
+
+**Scope:** Sample 5-10 obvious comment removals to demonstrate approach, not exhaustive
+
+---
+
+## Phase 3: Medium-Risk Improvements
+
+### 3.1 Simplify Signal Handler Pattern
+
+**Current (worker-service.ts:180-192 + ProcessManager.ts:294-317):**
+```typescript
+// 3-hop indirection with mutable reference
+const shutdownRef = { value: this.isShuttingDown };
+const handler = createSignalHandler(() => this.shutdown(), shutdownRef);
+process.on('SIGTERM', () => {
+  this.isShuttingDown = shutdownRef.value;  // Sync back
+  handler('SIGTERM');
+});
+```
+
+**Simplified approach:**
+```typescript
+private registerSignalHandlers(): void {
+  const handler = async (signal: string) => {
+    if (this.isShuttingDown) {
+      logger.warn('SYSTEM', `Received ${signal} but shutdown already in progress`);
+      return;
+    }
+    this.isShuttingDown = true;
+    logger.info('SYSTEM', `Received ${signal}, shutting down...`);
+    try {
+      await this.shutdown();
+      process.exit(0);
+    } catch (error) {
+      logger.error('SYSTEM', 'Error during shutdown', {}, error as Error);
+      process.exit(0);
+    }
+  };
+
+  process.on('SIGTERM', () => handler('SIGTERM'));
+  process.on('SIGINT', () => handler('SIGINT'));
+}
+```
+
+**Decision needed:** Does `createSignalHandler` serve other callers? If yes, keep factory but simplify worker usage.
+
+**Steps:**
+1. Grep `createSignalHandler` usage across codebase
+2. If only worker-service uses it, inline and simplify
+3. If shared, simplify worker's usage while keeping factory
+
+### 3.2 Unify Dual Initialization Tracking
+
+**Current (lines 111, 129-130):**
+```typescript
+private initializationCompleteFlag: boolean = false;
+private initializationComplete: Promise<void>;
+```
+
+**Recommendation:** Keep both but add clarifying comments:
+- Promise: For async waiters (HTTP handlers)
+- Flag: For sync checks (status endpoints)
+
+**Alternative:** Use Promise with inspection pattern:
+```typescript
+private initializationComplete = false;
+private initializationPromise: Promise<void>;
+// Flag derived from promise state via finally() callback
+```
+
+**Steps:**
+1. Add documentation comment explaining dual tracking purpose
+2. Consider if flag can be derived from promise state instead
+
+### 3.3 Reduce 5-Minute Timeout
+
+**Location:** Lines 464-478 (approximate)
+**Current:** `const timeoutMs = 300000; // 5 minutes`
+**Recommendation:** Reduce to 30-60 seconds for HTTP handler, keep 5min for MCP init
+
+**Caution:** MCP initialization can legitimately be slow (ChromaDB, model loading). May need different timeouts per use case.
+
+**Steps:**
+1. Find exact line for context inject timeout
+2. Verify this is separate from MCP init timeout
+3. Reduce HTTP handler timeout to 30-60 seconds
+4. Keep MCP init timeout at 5 minutes
+
+---
+
+## Phase 4: Deferred / Low Priority
+
+These items are noted but NOT part of this cleanup:
+
+| Issue | Reason to Defer |
+|-------|-----------------|
+| Exit code 0 always | Documented Windows Terminal workaround - intentional |
+| Re-export for circular import | Works correctly, architectural fix is separate work |
+| Fallback agent verification | Behavioral change, needs feature design |
+| MCP version hardcoding | Low impact, separate version management issue |
+| Empty capabilities | Documentation issue only |
+| Unsafe `as Error` casts | Common TS pattern, low risk |
+
+---
+
+## Phase 5: Verification
+
+### 5.1 Build Verification
+```bash
+npm run build
+```
+Expected: No errors
+
+### 5.2 Test Suite
+```bash
+npm test
+```
+Expected: All tests pass
+
+### 5.3 Grep for Anti-patterns
+```bash
+# Verify dead code removed
+grep -r "runInteractiveSetup" src/
+
+# Verify unused imports removed
+grep "import \* as fs from 'fs'" src/services/worker-service.ts
+grep "import { spawn }" src/services/worker-service.ts
+```
+Expected: No matches
+
+### 5.4 Runtime Check
+```bash
+npm run build-and-sync
+# Start worker and verify basic operation
+```
+
+---
+
+## Summary
+
+| Phase | Items | Estimated Reduction |
+|-------|-------|---------------------|
+| Phase 1 | Dead code + unused imports | ~210 lines |
+| Phase 2 | Low-risk simplifications | ~5 lines + clarity |
+| Phase 3 | Medium-risk improvements | ~30 lines |
+| Total | | ~245 lines (~30% reduction) |
+
+**Execution Order:** Phase 1 → Phase 2 → Phase 3 → Phase 5 (verification after each)
@@ -0,0 +1,516 @@
+# Fix CLAUDE.md Worktree Bug - Implementation Plan
+
+## Problem Statement
+
+CLAUDE.md files are being written to the wrong directory when using git worktrees. The worker service writes files relative to its own `process.cwd()` instead of the project's working directory (`cwd`) from the observation.
+
+**Reproduction scenario:**
+1. Start Claude Code in `budapest` worktree → worker starts with `cwd=budapest`
+2. Run Claude Code in `~/Scripts/claude-mem/` (main repo)
+3. Observations created with relative file paths (e.g., `src/utils/foo.ts`)
+4. `updateFolderClaudeMdFiles` writes to `budapest/src/utils/CLAUDE.md` instead of main repo
+
+## Root Cause Analysis
+
+The `cwd` (project root path) IS captured and stored:
+- `SessionRoutes.ts:309,403` - receives `cwd` from hooks
+- `PendingMessageStore.ts:70` - stores `cwd` in database
+- `SDKAgent.ts:295` - passes `cwd` to prompt builder
+
+But `cwd` is NOT passed to file writing:
+- `ResponseProcessor.ts:222-225` - calls `updateFolderClaudeMdFiles(allFilePaths, session.project, port)` without `cwd`
+- `claude-md-utils.ts:219` - uses `path.dirname(filePath)` which produces relative paths
+- Relative paths resolve against worker's `process.cwd()`, not project root
+
+---
+
+## Phase 0: Documentation & API Inventory
+
+### Allowed APIs (from codebase analysis)
+
+**File: `src/utils/claude-md-utils.ts`**
+```typescript
+export async function updateFolderClaudeMdFiles(
+  filePaths: string[],
+  project: string,
+  port: number
+): Promise<void>
+```
+
+**File: `src/sdk/parser.ts`**
+```typescript
+export interface ParsedObservation {
+  type: string;
+  title: string | null;
+  subtitle: string | null;
+  facts: string[];
+  narrative: string | null;
+  concepts: string[];
+  files_read: string[];
+  files_modified: string[];
+  // NOTE: Does NOT include cwd
+}
+```
+
+**File: `src/services/worker-types.ts`**
+```typescript
+export interface PendingMessage {
+  type: 'observation' | 'summarize';
+  tool_name?: string;
+  tool_input?: unknown;
+  tool_response?: unknown;
+  prompt_number?: number;
+  cwd?: string;  // <-- Source of project root
+  last_assistant_message?: string;
+}
+```
+
+**File: `src/shared/paths.ts`** - Path utilities
+```typescript
+import path from 'path';
+// Standard pattern: path.join(baseDir, relativePath)
+```
+
+### Anti-Patterns to Avoid
+
+1. **DO NOT** add `cwd` to `ParsedObservation` - it comes from message, not agent response
+2. **DO NOT** use `process.cwd()` for project-specific paths
+3. **DO NOT** assume file paths are absolute - they are relative from agent response
+4. **DO NOT** modify the parser - file paths come from agent XML output
+
+---
+
+## Phase 1: Add `projectRoot` Parameter to `updateFolderClaudeMdFiles`
+
+### What to implement
+
+Modify the function signature to accept an optional `projectRoot` parameter for resolving relative paths to absolute paths.
+
+### Files to modify
+
+**File: `src/utils/claude-md-utils.ts`**
+
+**Location: Lines 206-210 (function signature)**
+
+Current:
+```typescript
+export async function updateFolderClaudeMdFiles(
+  filePaths: string[],
+  project: string,
+  port: number
+): Promise<void>
+```
+
+New:
+```typescript
+export async function updateFolderClaudeMdFiles(
+  filePaths: string[],
+  project: string,
+  port: number,
+  projectRoot?: string
+): Promise<void>
+```
+
+**Location: Lines 215-228 (folder extraction logic)**
+
+Current:
+```typescript
+const folderPaths = new Set<string>();
+for (const filePath of filePaths) {
+  if (!filePath || filePath === '') continue;
+  const folderPath = path.dirname(filePath);
+  if (folderPath && folderPath !== '.' && folderPath !== '/') {
+    if (isProjectRoot(folderPath)) {
+      logger.debug('FOLDER_INDEX', 'Skipping project root CLAUDE.md', { folderPath });
+      continue;
+    }
+    folderPaths.add(folderPath);
+  }
+}
+```
+
+New:
+```typescript
+const folderPaths = new Set<string>();
+for (const filePath of filePaths) {
+  if (!filePath || filePath === '') continue;
+
+  // Resolve relative paths to absolute using projectRoot
+  let absoluteFilePath = filePath;
+  if (projectRoot && !path.isAbsolute(filePath)) {
+    absoluteFilePath = path.join(projectRoot, filePath);
+  }
+
+  const folderPath = path.dirname(absoluteFilePath);
+  if (folderPath && folderPath !== '.' && folderPath !== '/') {
+    if (isProjectRoot(folderPath)) {
+      logger.debug('FOLDER_INDEX', 'Skipping project root CLAUDE.md', { folderPath });
+      continue;
+    }
+    folderPaths.add(folderPath);
+  }
+}
+```
+
+### Documentation references
+
+- Pattern for `path.isAbsolute()`: Standard Node.js path module
+- Pattern for `path.join(base, relative)`: Used throughout `src/shared/paths.ts`
+
+### Verification checklist
+
+1. [ ] `grep -n "updateFolderClaudeMdFiles" src/utils/claude-md-utils.ts` shows new signature
+2. [ ] `grep -n "path.isAbsolute" src/utils/claude-md-utils.ts` confirms new check added
+3. [ ] `grep -n "projectRoot" src/utils/claude-md-utils.ts` shows parameter usage
+4. [ ] Existing callers still compile (optional param is backward compatible)
+
+### Anti-pattern guards
+
+- **DO NOT** make `projectRoot` required - breaks existing callers
+- **DO NOT** use `process.cwd()` as default - defeats purpose of fix
+- **DO NOT** modify the API endpoint format - path resolution is caller's responsibility
+
+---
+
+## Phase 2: Pass `cwd` from Message to `updateFolderClaudeMdFiles`
+
+### What to implement
+
+Extract `cwd` from the original messages being processed and pass it to `updateFolderClaudeMdFiles`.
+
+### Challenge
+
+The `syncAndBroadcastObservations` function receives `ParsedObservation[]` which does NOT include `cwd`. The `cwd` is in the original `PendingMessage` but is consumed during prompt generation.
+
+### Solution
+
+Add `projectRoot` parameter to `syncAndBroadcastObservations` and `processAgentResponse`, sourced from `session` or passed through from message processing.
+
+### Files to modify
+
+**File: `src/services/worker/agents/ResponseProcessor.ts`**
+
+**Step 1: Update `processAgentResponse` signature (lines 46-55)**
+
+Current:
+```typescript
+export async function processAgentResponse(
+  text: string,
+  session: ActiveSession,
+  dbManager: DatabaseManager,
+  sessionManager: SessionManager,
+  worker: WorkerRef | undefined,
+  discoveryTokens: number,
+  originalTimestamp: number | null,
+  agentName: string
+): Promise<void>
+```
+
+New:
+```typescript
+export async function processAgentResponse(
+  text: string,
+  session: ActiveSession,
+  dbManager: DatabaseManager,
+  sessionManager: SessionManager,
+  worker: WorkerRef | undefined,
+  discoveryTokens: number,
+  originalTimestamp: number | null,
+  agentName: string,
+  projectRoot?: string
+): Promise<void>
+```
+
+**Step 2: Pass `projectRoot` to `syncAndBroadcastObservations` (line 101-109)**
+
+Current:
+```typescript
+await syncAndBroadcastObservations(
+  observations,
+  result,
+  session,
+  dbManager,
+  worker,
+  discoveryTokens,
+  agentName
+);
+```
+
+New:
+```typescript
+await syncAndBroadcastObservations(
+  observations,
+  result,
+  session,
+  dbManager,
+  worker,
+  discoveryTokens,
+  agentName,
+  projectRoot
+);
+```
+
+**Step 3: Update `syncAndBroadcastObservations` signature (lines 153-161)**
+
+Current:
+```typescript
+async function syncAndBroadcastObservations(
+  observations: ParsedObservation[],
+  result: StorageResult,
+  session: ActiveSession,
+  dbManager: DatabaseManager,
+  worker: WorkerRef | undefined,
+  discoveryTokens: number,
+  agentName: string
+): Promise<void>
+```
+
+New:
+```typescript
+async function syncAndBroadcastObservations(
+  observations: ParsedObservation[],
+  result: StorageResult,
+  session: ActiveSession,
+  dbManager: DatabaseManager,
+  worker: WorkerRef | undefined,
+  discoveryTokens: number,
+  agentName: string,
+  projectRoot?: string
+): Promise<void>
+```
+
+**Step 4: Update `updateFolderClaudeMdFiles` call (lines 222-229)**
+
+Current:
+```typescript
+if (allFilePaths.length > 0) {
+  updateFolderClaudeMdFiles(
+    allFilePaths,
+    session.project,
+    getWorkerPort()
+  ).catch(error => {
+    logger.warn('FOLDER_INDEX', 'CLAUDE.md update failed (non-critical)', { project: session.project }, error as Error);
+  });
+}
+```
+
+New:
+```typescript
+if (allFilePaths.length > 0) {
+  updateFolderClaudeMdFiles(
+    allFilePaths,
+    session.project,
+    getWorkerPort(),
+    projectRoot
+  ).catch(error => {
+    logger.warn('FOLDER_INDEX', 'CLAUDE.md update failed (non-critical)', { project: session.project }, error as Error);
+  });
+}
+```
+
+### Verification checklist
+
+1. [ ] `grep -n "projectRoot" src/services/worker/agents/ResponseProcessor.ts` shows parameter throughout
+2. [ ] `grep -n "processAgentResponse" src/services/worker/*.ts` to find all callers
+3. [ ] TypeScript compiles without errors
+
+### Anti-pattern guards
+
+- **DO NOT** extract `cwd` from `ParsedObservation` - it doesn't have one
+- **DO NOT** store `cwd` on session globally - messages may come from different cwds (edge case)
+
+---
+
+## Phase 3: Update Agent Callers to Pass `cwd`
+
+### What to implement
+
+Update SDKAgent, GeminiAgent, and OpenRouterAgent to pass `message.cwd` to `processAgentResponse`.
+
+### Files to modify
+
+**File: `src/services/worker/SDKAgent.ts`**
+
+Find the `processAgentResponse` call and add the `projectRoot` parameter from `message.cwd`.
+
+**Pattern to follow (from SDKAgent.ts:289-296):**
+```typescript
+const obsPrompt = buildObservationPrompt({
+  id: 0,
+  tool_name: message.tool_name!,
+  tool_input: JSON.stringify(message.tool_input),
+  tool_output: JSON.stringify(message.tool_response),
+  created_at_epoch: Date.now(),
+  cwd: message.cwd  // <-- This is available
+});
+```
+
+**Challenge:** `processAgentResponse` is called after the SDK response, not in the message loop. Need to track `lastCwd` from messages.
+
+**Solution:** Store `lastCwd` from messages being processed and pass to `processAgentResponse`.
+
+**File: `src/services/worker/GeminiAgent.ts`** - Same pattern
+**File: `src/services/worker/OpenRouterAgent.ts`** - Same pattern
+
+### Implementation pattern for each agent
+
+Add tracking variable:
+```typescript
+let lastCwd: string | undefined;
+```
+
+In message loop, capture cwd:
+```typescript
+if (message.cwd) {
+  lastCwd = message.cwd;
+}
+```
+
+In `processAgentResponse` call:
+```typescript
+await processAgentResponse(
+  responseText,
+  session,
+  this.dbManager,
+  this.sessionManager,
+  worker,
+  discoveryTokens,
+  originalTimestamp,
+  'SDK',  // or 'Gemini' or 'OpenRouter'
+  lastCwd
+);
+```
+
+### Verification checklist
+
+1. [ ] `grep -n "lastCwd" src/services/worker/SDKAgent.ts` shows tracking
+2. [ ] `grep -n "lastCwd" src/services/worker/GeminiAgent.ts` shows tracking
+3. [ ] `grep -n "lastCwd" src/services/worker/OpenRouterAgent.ts` shows tracking
+4. [ ] `grep -n "processAgentResponse.*lastCwd" src/services/worker/` shows all calls updated
+
+### Anti-pattern guards
+
+- **DO NOT** use `session.cwd` - sessions can have messages from multiple cwds
+- **DO NOT** default to `process.cwd()` - defeats the fix
+
+---
+
+## Phase 4: Update Tests
+
+### What to implement
+
+Update existing tests and add new tests for the `projectRoot` functionality.
+
+### Files to modify
+
+**File: `tests/utils/claude-md-utils.test.ts`**
+
+Add test cases for:
+1. Relative paths with `projectRoot` resolve correctly
+2. Absolute paths ignore `projectRoot`
+3. Missing `projectRoot` maintains backward compatibility
+
+### Test pattern to copy
+
+From `tests/utils/claude-md-utils.test.ts:245-266` (folder deduplication test):
+```typescript
+it('should deduplicate folders from multiple files', async () => {
+  mockFetch.mockResolvedValue({
+    ok: true,
+    json: () => Promise.resolve({ content: [{ text: mockApiResponse }] })
+  });
+
+  await updateFolderClaudeMdFiles(
+    ['/project/src/utils/file1.ts', '/project/src/utils/file2.ts'],
+    'test-project',
+    37777
+  );
+
+  // Should only call API once for the deduplicated folder
+  expect(mockFetch).toHaveBeenCalledTimes(1);
+});
+```
+
+### New test to add
+
+```typescript
+it('should resolve relative paths using projectRoot', async () => {
+  mockFetch.mockResolvedValue({
+    ok: true,
+    json: () => Promise.resolve({ content: [{ text: mockApiResponse }] })
+  });
+
+  await updateFolderClaudeMdFiles(
+    ['src/utils/file.ts'],  // relative path
+    'test-project',
+    37777,
+    '/home/user/my-project'  // projectRoot
+  );
+
+  // Should write to absolute path /home/user/my-project/src/utils/CLAUDE.md
+  expect(mockWriteClaudeMd).toHaveBeenCalledWith(
+    '/home/user/my-project/src/utils',
+    expect.any(String)
+  );
+});
+```
+
+### Verification checklist
+
+1. [ ] `bun test tests/utils/claude-md-utils.test.ts` passes
+2. [ ] New test case for `projectRoot` exists and passes
+
+---
+
+## Phase 5: Final Verification
+
+### Verification commands
+
+```bash
+# 1. Confirm new parameter exists
+grep -n "projectRoot" src/utils/claude-md-utils.ts
+grep -n "projectRoot" src/services/worker/agents/ResponseProcessor.ts
+grep -n "lastCwd" src/services/worker/SDKAgent.ts
+
+# 2. Confirm path.isAbsolute check added
+grep -n "path.isAbsolute" src/utils/claude-md-utils.ts
+
+# 3. Confirm all agents updated
+grep -n "processAgentResponse.*lastCwd" src/services/worker/*.ts
+
+# 4. Run tests
+bun test tests/utils/claude-md-utils.test.ts
+
+# 5. Build and verify no TypeScript errors
+npm run build
+```
+
+### Anti-pattern grep checks
+
+```bash
+# Should NOT find process.cwd() in updateFolderClaudeMdFiles path logic
+grep -n "process.cwd" src/utils/claude-md-utils.ts
+
+# Should NOT find cwd in ParsedObservation interface
+grep -A 10 "interface ParsedObservation" src/sdk/parser.ts | grep cwd
+```
+
+### Manual testing
+
+1. Start worker in one directory
+2. Run Claude Code in a different directory (worktree)
+3. Make a code change that creates an observation
+4. Verify CLAUDE.md is written to the correct project directory
+
+---
+
+## Summary of Changes
+
+| File | Change |
+|------|--------|
+| `src/utils/claude-md-utils.ts` | Add `projectRoot` param, resolve relative paths |
+| `src/services/worker/agents/ResponseProcessor.ts` | Pass `projectRoot` through call chain |
+| `src/services/worker/SDKAgent.ts` | Track `lastCwd`, pass to `processAgentResponse` |
+| `src/services/worker/GeminiAgent.ts` | Track `lastCwd`, pass to `processAgentResponse` |
+| `src/services/worker/OpenRouterAgent.ts` | Track `lastCwd`, pass to `processAgentResponse` |
+| `tests/utils/claude-md-utils.test.ts` | Add tests for `projectRoot` behavior |
@@ -0,0 +1,266 @@
+# Plan: Fix Empty CLAUDE.md File Generation
+
+## Problem Statement
+
+Currently the CLAUDE.md generator creates files with wasteful content:
+1. **Empty files with "No recent activity"** - Files are created even when there are zero observations for a folder
+2. **Redundant HTML comment** - "<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->" is unnecessary since the `<claude-mem-context>` tag already conveys this information
+
+These issues create noisy, wasteful context that loads automatically and provides no value.
+
+## Phase 0: Documentation Discovery
+
+### Allowed APIs (from code analysis)
+- `formatTimelineForClaudeMd(timelineText: string): string` - src/utils/claude-md-utils.ts:139
+- `formatObservationsForClaudeMd(observations, folderPath): string` - scripts/regenerate-claude-md.ts:238
+- `writeClaudeMdToFolder(folderPath, newContent): void` - src/utils/claude-md-utils.ts:94
+- `updateFolderClaudeMdFiles(filePaths, project, port, projectRoot): Promise<void>` - src/utils/claude-md-utils.ts:257
+- `replaceTaggedContent(existingContent, newContent): string` - src/utils/claude-md-utils.ts:64
+
+### Key Locations
+| File | Lines | Purpose |
+|------|-------|---------|
+| `src/utils/claude-md-utils.ts` | 139-235 | Main formatting function |
+| `src/utils/claude-md-utils.ts` | 143 | HTML comment generation |
+| `src/utils/claude-md-utils.ts` | 209-211 | "No recent activity" handling |
+| `src/utils/claude-md-utils.ts` | 322-323 | Write decision point |
+| `scripts/regenerate-claude-md.ts` | 238-286 | Regeneration script formatting |
+| `scripts/regenerate-claude-md.ts` | 242 | HTML comment generation (duplicate) |
+| `scripts/regenerate-claude-md.ts` | 245-247 | "No recent activity" handling |
+| `scripts/regenerate-claude-md.ts` | 452-453 | Write decision point |
+| `tests/utils/claude-md-utils.test.ts` | 96-109 | Tests for "No recent activity" behavior |
+
+### Anti-patterns to avoid
+- Do NOT add new configuration options for this behavior - just fix it
+- Do NOT add logging for skipped files (unnecessary noise)
+
+---
+
+## Phase 1: Modify formatTimelineForClaudeMd to Return Empty on No Observations
+
+### Task 1.1: Update formatTimelineForClaudeMd return behavior
+**File:** `src/utils/claude-md-utils.ts`
+**Lines:** 139-235
+
+**Changes:**
+1. Remove HTML comment line at line 143
+2. Change the empty observations case (lines 209-211) to return an empty string instead of "No recent activity"
+
+**Before (lines 141-144):**
+```typescript
+lines.push('# Recent Activity');
+lines.push('');
+lines.push('<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->');
+lines.push('');
+```
+
+**After:**
+```typescript
+lines.push('# Recent Activity');
+lines.push('');
+```
+
+**Before (lines 209-212):**
+```typescript
+if (observations.length === 0) {
+  lines.push('*No recent activity*');
+  return lines.join('\n');
+}
+```
+
+**After:**
+```typescript
+if (observations.length === 0) {
+  return '';
+}
+```
+
+### Verification
+- Run `bun test tests/utils/claude-md-utils.test.ts`
+- Tests at lines 96-109 will FAIL (expected - they test for "No recent activity")
+- Update tests to expect empty string for empty input
+
+---
+
+## Phase 2: Update updateFolderClaudeMdFiles to Skip Empty Content
+
+### Task 2.1: Add empty content check before writing
+**File:** `src/utils/claude-md-utils.ts`
+**Lines:** 322-323
+
+**Changes:**
+After formatting, check if result is empty and skip writing if so.
+
+**Before (lines 321-325):**
+```typescript
+const formatted = formatTimelineForClaudeMd(result.content[0].text);
+writeClaudeMdToFolder(folderPath, formatted);
+
+logger.debug('FOLDER_INDEX', 'Updated CLAUDE.md', { folderPath });
+```
+
+**After:**
+```typescript
+const formatted = formatTimelineForClaudeMd(result.content[0].text);
+if (!formatted) {
+  logger.debug('FOLDER_INDEX', 'No observations for folder, skipping', { folderPath });
+  continue;
+}
+writeClaudeMdToFolder(folderPath, formatted);
+
+logger.debug('FOLDER_INDEX', 'Updated CLAUDE.md', { folderPath });
+```
+
+### Verification
+- Grep for files containing "No recent activity": should find none after running
+
+---
+
+## Phase 3: Update Regeneration Script
+
+### Task 3.1: Remove HTML comment from formatObservationsForClaudeMd
+**File:** `scripts/regenerate-claude-md.ts`
+**Lines:** 238-286
+
+**Changes:**
+1. Remove HTML comment line at line 242
+2. Change empty observations case (lines 245-247) to return empty string
+
+**Before (lines 240-244):**
+```typescript
+lines.push('# Recent Activity');
+lines.push('');
+lines.push('<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->');
+lines.push('');
+```
+
+**After:**
+```typescript
+lines.push('# Recent Activity');
+lines.push('');
+```
+
+**Before (lines 245-248):**
+```typescript
+if (observations.length === 0) {
+  lines.push('*No recent activity*');
+  return lines.join('\n');
+}
+```
+
+**After:**
+```typescript
+if (observations.length === 0) {
+  return '';
+}
+```
+
+### Task 3.2: Update regenerateFolder to handle empty formatted content
+**File:** `scripts/regenerate-claude-md.ts`
+**Lines:** 432-459
+
+The script already skips folders with no observations (lines 443-444), so this change is already compatible. The `formatObservationsForClaudeMd` returning empty string doesn't change behavior since observations are checked before calling it.
+
+### Verification
+- Run `bun scripts/regenerate-claude-md.ts --dry-run` in the project
+- Should NOT show any folders with 0 observations
+
+---
+
+## Phase 4: Update Tests
+
+### Task 4.1: Update tests for new empty behavior
+**File:** `tests/utils/claude-md-utils.test.ts`
+**Lines:** 96-109
+
+**Changes:**
+Update the two tests that expect "No recent activity" to expect empty string instead.
+
+**Before (lines 96-101):**
+```typescript
+it('should return "No recent activity" for empty input', () => {
+  const result = formatTimelineForClaudeMd('');
+
+  expect(result).toContain('# Recent Activity');
+  expect(result).toContain('*No recent activity*');
+});
+```
+
+**After:**
+```typescript
+it('should return empty string for empty input', () => {
+  const result = formatTimelineForClaudeMd('');
+
+  expect(result).toBe('');
+});
+```
+
+**Before (lines 103-109):**
+```typescript
+it('should return "No recent activity" when no table rows exist', () => {
+  const input = 'Just some plain text without table rows';
+
+  const result = formatTimelineForClaudeMd(input);
+
+  expect(result).toContain('*No recent activity*');
+});
+```
+
+**After:**
+```typescript
+it('should return empty string when no table rows exist', () => {
+  const input = 'Just some plain text without table rows';
+
+  const result = formatTimelineForClaudeMd(input);
+
+  expect(result).toBe('');
+});
+```
+
+### Task 4.2: Remove HTML comment assertions from any other tests
+Search for tests that assert on "auto-generated" comment and update accordingly.
+
+### Verification
+- Run full test suite: `bun test`
+- All tests should pass
+
+---
+
+## Phase 5: Cleanup Existing Empty Files
+
+### Task 5.1: Run cleanup to remove existing empty CLAUDE.md files
+**Command:**
+```bash
+bun scripts/regenerate-claude-md.ts --clean
+```
+
+This will:
+- Find all CLAUDE.md files with `<claude-mem-context>` tags
+- Strip the tagged section
+- Delete files that become empty after stripping
+- Preserve files that have user content outside the tags
+
+### Verification
+- `grep -r "No recent activity" . --include="CLAUDE.md"` should return no results
+- `grep -r "auto-generated by claude-mem" . --include="CLAUDE.md"` should return no results
+
+---
+
+## Summary of Changes
+
+| File | Change |
+|------|--------|
+| `src/utils/claude-md-utils.ts:143` | Remove HTML comment line |
+| `src/utils/claude-md-utils.ts:209-211` | Return empty string instead of "No recent activity" |
+| `src/utils/claude-md-utils.ts:322` | Skip writing if formatted content is empty |
+| `scripts/regenerate-claude-md.ts:242` | Remove HTML comment line |
+| `scripts/regenerate-claude-md.ts:245-247` | Return empty string instead of "No recent activity" |
+| `tests/utils/claude-md-utils.test.ts:96-109` | Update tests to expect empty string |
+
+## Final Verification Checklist
+- [ ] `bun test` passes
+- [ ] No "No recent activity" CLAUDE.md files exist
+- [ ] No "auto-generated" comments in CLAUDE.md files
+- [ ] Build succeeds: `npm run build-and-sync`
+- [ ] New observations correctly generate CLAUDE.md files with content
+- [ ] Folders without observations get no CLAUDE.md file created
@@ -0,0 +1,252 @@
+# Plan: Fix Stale Session Resume Crash
+
+## Problem Summary
+
+The worker crashes repeatedly with "Claude Code process exited with code 1" when attempting to resume into a stale/non-existent SDK session.
+
+**Root Cause:** In `SDKAgent.ts:94`, the resume parameter is passed whenever `memorySessionId` exists in the database, regardless of whether this is an INIT prompt or CONTINUATION prompt. When a worker restarts or re-initializes a session, it loads a stale `memorySessionId` from a previous SDK session and tries to resume into a session that no longer exists in Claude's context.
+
+**Evidence from logs:**
+```
+[17:30:21.773] Starting SDK query {
+  hasRealMemorySessionId=true,           ← DB has old memorySessionId
+  resume_parameter=5439891b-...,         ← Trying to resume with it
+  lastPromptNumber=1                     ← But this is a NEW SDK session!
+}
+[17:30:24.450] Generator failed {error=Claude Code process exited with code 1}
+```
+
+---
+
+## Phase 0: Documentation Discovery (COMPLETED)
+
+### Allowed APIs (from subagent research)
+
+**V1 SDK API (currently used):**
+```typescript
+// From @anthropic-ai/claude-agent-sdk
+function query(options: {
+  prompt: string | AsyncIterable<SDKUserMessage>;
+  options: {
+    model: string;
+    resume?: string;  // SESSION ID - only use for CONTINUATION
+    disallowedTools?: string[];
+    abortController?: AbortController;
+    pathToClaudeCodeExecutable?: string;
+  }
+}): AsyncIterable<SDKMessage>
+```
+
+**Resume Parameter Rules (from docs/context/agent-sdk-v2-preview.md and SESSION_ID_ARCHITECTURE.md):**
+- `resume` should only be used when continuing an existing SDK conversation
+- For INIT prompts (first prompt in a fresh SDK session), no resume parameter should be passed
+- Session ID is captured from first SDK message and stored for subsequent prompts
+
+### Anti-Patterns to Avoid
+- Passing `resume` parameter with INIT prompts (causes crash)
+- Using `contentSessionId` for resume (contaminates user session)
+- Assuming memorySessionId validity without checking prompt context
+
+---
+
+## Phase 1: Fix the Resume Parameter Logic
+
+### What to Implement
+
+Modify `src/services/worker/SDKAgent.ts` line 94 to check BOTH conditions:
+1. `hasRealMemorySessionId` - memorySessionId exists and is non-null
+2. `session.lastPromptNumber > 1` - this is a CONTINUATION, not an INIT prompt
+
+### Current Code (line 89-99):
+```typescript
+const queryResult = query({
+  prompt: messageGenerator,
+  options: {
+    model: modelId,
+    // Resume with captured memorySessionId (null on first prompt, real ID on subsequent)
+    ...(hasRealMemorySessionId && { resume: session.memorySessionId }),
+    disallowedTools,
+    abortController: session.abortController,
+    pathToClaudeCodeExecutable: claudePath
+  }
+});
+```
+
+### Fixed Code:
+```typescript
+const queryResult = query({
+  prompt: messageGenerator,
+  options: {
+    model: modelId,
+    // Only resume if BOTH: (1) we have a memorySessionId AND (2) this isn't the first prompt
+    // On worker restart, memorySessionId may exist from a previous SDK session but we
+    // need to start fresh since the SDK context was lost
+    ...(hasRealMemorySessionId && session.lastPromptNumber > 1 && { resume: session.memorySessionId }),
+    disallowedTools,
+    abortController: session.abortController,
+    pathToClaudeCodeExecutable: claudePath
+  }
+});
+```
+
+### Also Update the Comment at Line 66-68:
+```typescript
+// CRITICAL: Only resume if:
+// 1. memorySessionId exists (was captured from a previous SDK response)
+// 2. lastPromptNumber > 1 (this is a continuation within the same SDK session)
+// On worker restart or crash recovery, memorySessionId may exist from a previous
+// SDK session but we must NOT resume because the SDK context was lost.
+// NEVER use contentSessionId for resume - that would inject messages into the user's transcript!
+```
+
+### Verification Checklist
+- [ ] `grep "hasRealMemorySessionId && session.lastPromptNumber > 1" src/services/worker/SDKAgent.ts` returns the fix
+- [ ] Build succeeds: `npm run build`
+- [ ] No TypeScript errors
+
+---
+
+## Phase 2: Add Logging for Debugging
+
+### What to Implement
+
+Enhance the alignment log at line 81-85 to clearly indicate when resume is skipped due to INIT prompt:
+
+```typescript
+// Debug-level alignment logs for detailed tracing
+if (session.lastPromptNumber > 1) {
+  const willResume = hasRealMemorySessionId;
+  logger.debug('SDK', `[ALIGNMENT] Resume Decision | contentSessionId=${session.contentSessionId} | memorySessionId=${session.memorySessionId} | prompt#=${session.lastPromptNumber} | hasRealMemorySessionId=${hasRealMemorySessionId} | willResume=${willResume} | resumeWith=${willResume ? session.memorySessionId : 'NONE'}`);
+} else {
+  // INIT prompt - never resume even if memorySessionId exists (stale from previous session)
+  const hasStaleMemoryId = hasRealMemorySessionId;
+  logger.debug('SDK', `[ALIGNMENT] First Prompt (INIT) | contentSessionId=${session.contentSessionId} | prompt#=${session.lastPromptNumber} | hasStaleMemoryId=${hasStaleMemoryId} | action=START_FRESH | Will capture new memorySessionId from SDK response`);
+  if (hasStaleMemoryId) {
+    logger.warn('SDK', `Skipping resume for INIT prompt despite existing memorySessionId=${session.memorySessionId} - SDK context was lost (worker restart or crash recovery)`);
+  }
+}
+```
+
+### Verification Checklist
+- [ ] Build succeeds: `npm run build`
+- [ ] Log message appears when running with stale session scenario
+
+---
+
+## Phase 3: Add Unit Tests
+
+### What to Implement
+
+Create tests in `tests/sdk-agent-resume.test.ts` following patterns from `tests/session_id_usage_validation.test.ts`:
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+
+describe('SDKAgent Resume Parameter Logic', () => {
+  describe('hasRealMemorySessionId check', () => {
+    it('should NOT pass resume parameter when lastPromptNumber === 1 even if memorySessionId exists', () => {
+      // Scenario: Worker restart with stale memorySessionId
+      const session = {
+        memorySessionId: 'stale-session-id-from-previous-run',
+        lastPromptNumber: 1,  // INIT prompt
+      };
+
+      const hasRealMemorySessionId = !!session.memorySessionId;
+      const shouldResume = hasRealMemorySessionId && session.lastPromptNumber > 1;
+
+      expect(hasRealMemorySessionId).toBe(true);  // memorySessionId exists
+      expect(shouldResume).toBe(false);  // but should NOT resume
+    });
+
+    it('should pass resume parameter when lastPromptNumber > 1 AND memorySessionId exists', () => {
+      // Scenario: Normal continuation within same SDK session
+      const session = {
+        memorySessionId: 'valid-session-id',
+        lastPromptNumber: 2,  // CONTINUATION prompt
+      };
+
+      const hasRealMemorySessionId = !!session.memorySessionId;
+      const shouldResume = hasRealMemorySessionId && session.lastPromptNumber > 1;
+
+      expect(hasRealMemorySessionId).toBe(true);
+      expect(shouldResume).toBe(true);
+    });
+
+    it('should NOT pass resume parameter when memorySessionId is null', () => {
+      // Scenario: Fresh session, no captured ID yet
+      const session = {
+        memorySessionId: null,
+        lastPromptNumber: 1,
+      };
+
+      const hasRealMemorySessionId = !!session.memorySessionId;
+      const shouldResume = hasRealMemorySessionId && session.lastPromptNumber > 1;
+
+      expect(hasRealMemorySessionId).toBe(false);
+      expect(shouldResume).toBe(false);
+    });
+  });
+});
+```
+
+### Documentation Reference
+- Pattern: `tests/session_id_usage_validation.test.ts` lines 1-50 for test structure
+- Mock pattern: `tests/worker/agents/response-processor.test.ts` for session mocking
+
+### Verification Checklist
+- [ ] Tests pass: `bun test tests/sdk-agent-resume.test.ts`
+- [ ] Test file follows project conventions
+
+---
+
+## Phase 4: Build and Deploy
+
+### What to Implement
+
+1. Build the plugin: `npm run build-and-sync`
+2. Verify worker restarts with fix applied
+
+### Verification Checklist
+- [ ] `npm run build-and-sync` succeeds
+- [ ] Worker health check passes: `curl http://localhost:37777/api/health`
+- [ ] No "Claude Code process exited with code 1" errors in logs after restart
+
+---
+
+## Phase 5: Final Verification
+
+### Verification Commands
+
+```bash
+# 1. Verify fix is in place
+grep -n "hasRealMemorySessionId && session.lastPromptNumber > 1" src/services/worker/SDKAgent.ts
+
+# 2. Verify no crashes in recent logs
+tail -100 ~/.claude-mem/logs/claude-mem-$(date +%Y-%m-%d).log | grep -c "exited with code 1"
+
+# 3. Run tests
+bun test tests/sdk-agent-resume.test.ts
+
+# 4. Check for anti-patterns (should return 0 results)
+grep -n "hasRealMemorySessionId && { resume" src/services/worker/SDKAgent.ts
+```
+
+### Success Criteria
+- [ ] Fix in place at SDKAgent.ts:94
+- [ ] Zero "exited with code 1" errors related to stale resume
+- [ ] All tests pass
+- [ ] Worker stable for 10+ minutes without crash loop
+
+---
+
+## Files to Modify
+
+1. `src/services/worker/SDKAgent.ts` - Fix resume logic (Phase 1 & 2)
+2. `tests/sdk-agent-resume.test.ts` - New test file (Phase 3)
+
+## Estimated Complexity
+
+- **Phase 1**: Low - Single line change with updated condition
+- **Phase 2**: Low - Enhanced logging
+- **Phase 3**: Medium - New test file following existing patterns
+- **Phase 4-5**: Low - Standard build/verify process
@@ -0,0 +1,298 @@
+# Folder CLAUDE.md Generator
+
+## CORE DIRECTIVE (NON-NEGOTIABLE)
+
+**EXTEND THE EXISTING CURSOR RULES TIMELINE GENERATION SYSTEM TO ALSO WRITE CLAUDE.MD FILES**
+
+- DO NOT create new services
+- DO NOT create new orchestrators
+- DO NOT create new HTTP routes
+- DO NOT create new database query functions
+- EXTEND existing functions to add folder-level output
+
+---
+
+## Approved Directives (From Planning Conversation)
+
+### Trigger Mechanism
+- Observation save triggers folder CLAUDE.md regeneration **INLINE**
+- NO batching
+- NO debouncing
+- NO Set-based queuing
+- NO session-end hook
+- Synchronous: `observation.save()` → update folder CLAUDE.md files → done
+
+### Tag Strategy
+- Wrap ONLY auto-generated content with `<claude-mem-context>` tags
+- Everything outside tags is untouched (user's manual content preserved)
+- If tags are deleted, just regenerate them
+- NO backup system
+- NO manual content markers
+
+### Git Behavior
+- CLAUDE.md files SHOULD be committed (intentional)
+- `<claude-mem-context>` tag is searchable fingerprint for GitHub analytics
+- NO .gitignore for these files
+
+### Phasing
+- **Phase 1**: CLAUDE.md generation only (THIS PLAN)
+- **Phase 2**: IDE symlinks (FUTURE)
+
+### REJECTED
+- Cross-folder linking — NO
+- Semantic grouping — deferred enhancement only
+- Team sync — future phase
+
+### DEFERRED
+- Priority weighting by observation type
+- IDE-specific template refinements
+
+---
+
+## Phase 0: Documentation Discovery (COMPLETED)
+
+### Existing APIs to USE (Not Rebuild)
+
+| Function | Location | Purpose |
+|----------|----------|---------|
+| `findByFile(filePath, options)` | `src/services/sqlite/SessionSearch.ts:342` | Query observations by folder prefix (already supports LIKE wildcards) |
+| `updateCursorContextForProject()` | `src/services/integrations/CursorHooksInstaller.ts:98` | Write context files after observation save |
+| `writeContextFile()` | `src/utils/cursor-utils.ts:97` | Atomic file write with temp file + rename |
+| `extractFirstFile()` | `src/shared/timeline-formatting.ts` | Extract file paths from JSON arrays |
+| `groupByDate()` | `src/shared/timeline-formatting.ts` | Group items chronologically |
+| `formatTime()`, `formatDate()` | `src/shared/timeline-formatting.ts` | Time formatting |
+
+### Existing Integration Points
+
+| Location | What Happens | Extension Point |
+|----------|--------------|-----------------|
+| `ResponseProcessor.ts:266` | Calls `updateCursorContextForProject()` after summary save | Add folder CLAUDE.md update here |
+| `CursorHooksInstaller.ts:98` | `updateCursorContextForProject()` fetches context and writes file | Add sibling function for folder updates |
+
+### Anti-Patterns to AVOID
+- Creating `FolderIndexOrchestrator.ts` — NO
+- Creating `FolderTimelineCompiler.ts` — NO
+- Creating `FolderDiscovery.ts` — NO
+- Creating `ClaudeMdGenerator.ts` — NO
+- Creating `FolderIndexRoutes.ts` — NO
+- Adding new HTTP endpoints — NO
+- Adding new settings in `SettingsDefaultsManager.ts` — NO (use sensible defaults inline)
+
+---
+
+## Phase 1: Extend CursorHooksInstaller
+
+### What to Implement
+
+Add ONE new function to `src/services/integrations/CursorHooksInstaller.ts`:
+
+```typescript
+/**
+ * Update CLAUDE.md files for folders touched by an observation.
+ * Called inline after observation save, similar to updateCursorContextForProject.
+ */
+export async function updateFolderClaudeMd(
+  workspacePath: string,
+  filesModified: string[],
+  filesRead: string[],
+  project: string,
+  port: number
+): Promise<void>
+```
+
+### Implementation Pattern (Copy From)
+
+Follow the EXACT pattern of `updateCursorContextForProject()` at line 98:
+1. Extract unique folder paths from filesModified and filesRead
+2. For each folder, fetch timeline via existing `/api/search/file?files=<folderPath>` endpoint
+3. Format as simple timeline (reuse existing formatters)
+4. Write to `<folder>/CLAUDE.md` preserving content outside `<claude-mem-context>` tags
+
+### Tag Preservation Logic
+
+```typescript
+function replaceTaggedContent(existingContent: string, newContent: string): string {
+  const startTag = '<claude-mem-context>';
+  const endTag = '</claude-mem-context>';
+
+  // If no existing content, wrap new content in tags
+  if (!existingContent) {
+    return `${startTag}\n${newContent}\n${endTag}`;
+  }
+
+  // If existing has tags, replace only tagged section
+  const startIdx = existingContent.indexOf(startTag);
+  const endIdx = existingContent.indexOf(endTag);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    return existingContent.substring(0, startIdx) +
+           `${startTag}\n${newContent}\n${endTag}` +
+           existingContent.substring(endIdx + endTag.length);
+  }
+
+  // If no tags exist, append tagged content at end
+  return existingContent + `\n\n${startTag}\n${newContent}\n${endTag}`;
+}
+```
+
+### Verification Checklist
+- [ ] Function added to CursorHooksInstaller.ts
+- [ ] Uses existing `findByFile` endpoint (no new database queries)
+- [ ] Preserves content outside `<claude-mem-context>` tags
+- [ ] Atomic writes (temp file + rename)
+- [ ] Build passes: `npm run build`
+
+---
+
+## Phase 2: Hook Into ResponseProcessor
+
+### What to Implement
+
+Add call to `updateFolderClaudeMd()` in `src/services/worker/agents/ResponseProcessor.ts`, right after the existing `updateCursorContextForProject()` call at line 266.
+
+### Code Location
+
+In `syncAndBroadcastSummary()` function, after line 269:
+
+```typescript
+// EXISTING: Update Cursor context file for registered projects (fire-and-forget)
+updateCursorContextForProject(session.project, getWorkerPort()).catch(error => {
+  logger.warn('CURSOR', 'Context update failed (non-critical)', { project: session.project }, error as Error);
+});
+
+// NEW: Update folder CLAUDE.md files for touched folders (fire-and-forget)
+// Extract file paths from the saved observations
+updateFolderClaudeMd(
+  workspacePath,  // From registry lookup
+  filesModified,  // From observations
+  filesRead,      // From observations
+  session.project,
+  getWorkerPort()
+).catch(error => {
+  logger.warn('FOLDER_INDEX', 'CLAUDE.md update failed (non-critical)', { project: session.project }, error as Error);
+});
+```
+
+### Data Flow
+1. `processAgentResponse()` saves observations → gets back `observationIds`
+2. Fetch observation records to get `files_read` and `files_modified`
+3. Pass to `updateFolderClaudeMd()`
+
+### Verification Checklist
+- [ ] Call added to ResponseProcessor.ts
+- [ ] Fire-and-forget pattern (non-blocking, errors logged)
+- [ ] Uses existing observation data (no new queries)
+- [ ] Build passes: `npm run build`
+
+---
+
+## Phase 3: Timeline Formatting
+
+### What to Implement
+
+Create a minimal timeline formatter for CLAUDE.md output. This can be:
+1. A simple function in CursorHooksInstaller.ts, OR
+2. Reuse existing `ResultFormatter.formatSearchResults()` from `src/services/worker/search/ResultFormatter.ts`
+
+### Output Format
+
+```markdown
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+<claude-mem-context>
+
+### 2026-01-04
+
+| Time | Type | Title |
+|------|------|-------|
+| 4:30pm | feature | Added folder index support |
+| 3:15pm | bugfix | Fixed file path handling |
+
+### 2026-01-03
+
+| Time | Type | Title |
+|------|------|-------|
+| 11:00am | refactor | Cleaned up cursor utils |
+
+</claude-mem-context>
+```
+
+### Key Points
+- Compact format (time, type emoji, title only)
+- Grouped by date
+- Limited to last N days or observations (sensible default: 10)
+- NO token counts
+- NO file columns (redundant - we're IN the folder)
+
+### Verification Checklist
+- [ ] Formatter produces clean markdown
+- [ ] Output is concise (not verbose)
+- [ ] Grouped by date
+- [ ] Build passes: `npm run build`
+
+---
+
+## Phase 4: Verification
+
+### Functional Tests
+
+1. **Manual Test**:
+   - Start worker: `npm run dev`
+   - Create a test observation touching `src/services/sqlite/`
+   - Verify `src/services/sqlite/CLAUDE.md` is created/updated
+   - Verify `<claude-mem-context>` tags are present
+   - Verify manual content outside tags is preserved
+
+2. **Build Check**:
+   ```bash
+   npm run build
+   ```
+
+3. **Grep for Anti-Patterns**:
+   ```bash
+   # Should find NOTHING
+   grep -r "FolderIndexOrchestrator" src/
+   grep -r "FolderTimelineCompiler" src/
+   grep -r "FolderDiscovery" src/
+   grep -r "ClaudeMdGenerator" src/
+   grep -r "FolderIndexRoutes" src/
+   ```
+
+4. **Grep for Correct Implementation**:
+   ```bash
+   # Should find the new function
+   grep -r "updateFolderClaudeMd" src/
+   ```
+
+### Tag Preservation Test
+
+1. Create `src/test-folder/CLAUDE.md` with manual content:
+   ```markdown
+   # My Notes
+   This is manual content I wrote.
+   ```
+
+2. Trigger observation save touching files in `src/test-folder/`
+
+3. Verify result:
+   ```markdown
+   # My Notes
+   This is manual content I wrote.
+
+   <claude-mem-context>
+   ### 2026-01-04
+   | Time | Type | Title |
+   ...
+   </claude-mem-context>
+   ```
+
+---
+
+## Summary
+
+This is a **~100 line change** spread across 2 files:
+1. `CursorHooksInstaller.ts` — Add `updateFolderClaudeMd()` function (~60 lines)
+2. `ResponseProcessor.ts` — Add call to the new function (~10 lines)
+
+NO new files. NO new services. NO new routes. Just extending existing patterns.
@@ -0,0 +1,378 @@
+# Folder CLAUDE.md Refactor - Extract to Shared Utils
+
+## CORE DIRECTIVE
+
+**DECOUPLE FOLDER CLAUDE.MD WRITING FROM CURSOR INTEGRATION**
+
+The current implementation incorrectly couples folder-level CLAUDE.md generation to Cursor-specific registry lookups. The file paths from observations are already absolute - no workspace registry lookup is needed.
+
+---
+
+## Phase 0: Documentation Discovery (COMPLETED)
+
+### Current Implementation Location
+
+| Function | Location | Lines | Purpose |
+|----------|----------|-------|---------|
+| `updateFolderClaudeMd` | CursorHooksInstaller.ts | 128-199 | Orchestrates folder CLAUDE.md updates |
+| `formatTimelineForClaudeMd` | CursorHooksInstaller.ts | 221-295 | Parses API response to markdown |
+| `replaceTaggedContent` | CursorHooksInstaller.ts | 300-321 | Preserves user content outside tags |
+| `writeFolderClaudeMd` | CursorHooksInstaller.ts | 326-353 | Atomic file write |
+
+### Integration Point
+
+**File:** `src/services/worker/agents/ResponseProcessor.ts:274-298`
+
+Current (problematic) code:
+```typescript
+const registry = readCursorRegistry();
+const registryEntry = registry[session.project];
+
+if (registryEntry && (filesModified.length > 0 || filesRead.length > 0)) {
+  updateFolderClaudeMd(
+    registryEntry.workspacePath,  // <-- PROBLEM: Needs Cursor registry
+    filesModified,
+    filesRead,
+    session.project,
+    getWorkerPort()
+  ).catch(error => { ... });
+}
+```
+
+### The Problem
+
+1. `filesModified` and `filesRead` already contain **absolute paths**
+2. We don't need `workspacePath` - just extract folder from file path directly
+3. Cursor registry is only populated when Cursor hooks are installed
+4. This makes folder CLAUDE.md a Cursor-only feature (unintended)
+
+### Project Utils Pattern
+
+**From `src/utils/cursor-utils.ts:97-122`:**
+- Pure functions with paths as parameters
+- Atomic write pattern: temp file + rename
+- `mkdirSync(dir, { recursive: true })` for directory creation
+
+### Related Utils
+
+**`src/utils/tag-stripping.ts`** - Handles *stripping* tags (input filtering)
+- `stripMemoryTagsFromJson()` - removes `<claude-mem-context>` content
+- `stripMemoryTagsFromPrompt()` - removes `<private>` content
+
+Our `replaceTaggedContent` handles *preserving/replacing* (output writing) - complementary, not duplicative.
+
+---
+
+## Phase 1: Create Shared Utils File
+
+### What to Implement
+
+Create `src/utils/claude-md-utils.ts` with extracted and simplified functions.
+
+### File Structure
+
+```typescript
+/**
+ * CLAUDE.md File Utilities
+ *
+ * Shared utilities for writing folder-level CLAUDE.md files with
+ * auto-generated context sections. Preserves user content outside
+ * <claude-mem-context> tags.
+ */
+
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+import path from 'path';
+import { logger } from './logger.js';
+
+/**
+ * Replace tagged content in existing file, preserving content outside tags.
+ *
+ * Handles three cases:
+ * 1. No existing content → wraps new content in tags
+ * 2. Has existing tags → replaces only tagged section
+ * 3. No tags in existing content → appends tagged content at end
+ */
+export function replaceTaggedContent(existingContent: string, newContent: string): string {
+  // Copy from CursorHooksInstaller.ts:300-321
+}
+
+/**
+ * Write CLAUDE.md file to folder with atomic writes.
+ * Creates directory structure if needed.
+ *
+ * @param folderPath - Absolute path to the folder
+ * @param newContent - Content to write inside tags
+ */
+export function writeClaudeMdToFolder(folderPath: string, newContent: string): void {
+  // Simplified from writeFolderClaudeMd - no workspacePath needed
+  // Copy atomic write pattern from CursorHooksInstaller.ts:326-353
+}
+
+/**
+ * Format timeline text from API response to compact CLAUDE.md format.
+ *
+ * @param timelineText - Raw API response text
+ * @returns Formatted markdown with date headers and compact table
+ */
+export function formatTimelineForClaudeMd(timelineText: string): string {
+  // Copy from CursorHooksInstaller.ts:221-295
+}
+```
+
+### Key Simplification
+
+**OLD `writeFolderClaudeMd` signature:**
+```typescript
+async function writeFolderClaudeMd(
+  workspacePath: string,  // <-- REMOVE
+  folderPath: string,
+  newContent: string
+): Promise<void>
+```
+
+**NEW `writeClaudeMdToFolder` signature:**
+```typescript
+export function writeClaudeMdToFolder(
+  folderPath: string,     // Must be absolute path
+  newContent: string
+): void                   // Sync is fine, atomic anyway
+```
+
+### Verification Checklist
+- [ ] File created at `src/utils/claude-md-utils.ts`
+- [ ] `replaceTaggedContent` exported and handles all 3 cases
+- [ ] `writeClaudeMdToFolder` exported with atomic writes
+- [ ] `formatTimelineForClaudeMd` exported
+- [ ] Build passes: `npm run build`
+
+---
+
+## Phase 2: Create Folder Index Service Function
+
+### What to Implement
+
+Create a new orchestrating function that replaces `updateFolderClaudeMd`. This should NOT be in CursorHooksInstaller - it's a general feature.
+
+**Option A:** Add to `src/utils/claude-md-utils.ts` (keeps it simple)
+**Option B:** Create `src/services/folder-index-service.ts` (follows service pattern)
+
+Recommend **Option A** for simplicity - it's just one function.
+
+### New Function
+
+```typescript
+/**
+ * Update CLAUDE.md files for folders containing the given files.
+ * Fetches timeline from worker API and writes formatted content.
+ *
+ * @param filePaths - Array of absolute file paths (modified or read)
+ * @param project - Project identifier for API query
+ * @param port - Worker API port
+ */
+export async function updateFolderClaudeMdFiles(
+  filePaths: string[],
+  project: string,
+  port: number
+): Promise<void> {
+  // Extract unique folder paths from file paths
+  const folderPaths = new Set<string>();
+  for (const filePath of filePaths) {
+    if (!filePath || filePath === '') continue;
+    const folderPath = path.dirname(filePath);
+    if (folderPath && folderPath !== '.' && folderPath !== '/') {
+      folderPaths.add(folderPath);
+    }
+  }
+
+  if (folderPaths.size === 0) return;
+
+  logger.debug('FOLDER_INDEX', 'Updating CLAUDE.md files', {
+    project,
+    folderCount: folderPaths.size
+  });
+
+  // Process each folder
+  for (const folderPath of folderPaths) {
+    try {
+      // Fetch timeline via existing API
+      const response = await fetch(
+        `http://127.0.0.1:${port}/api/search/by-file?filePath=${encodeURIComponent(folderPath)}&limit=10&project=${encodeURIComponent(project)}`
+      );
+
+      if (!response.ok) {
+        logger.warn('FOLDER_INDEX', 'Failed to fetch timeline', { folderPath, status: response.status });
+        continue;
+      }
+
+      const result = await response.json();
+      if (!result.content?.[0]?.text) {
+        logger.debug('FOLDER_INDEX', 'No content for folder', { folderPath });
+        continue;
+      }
+
+      const formatted = formatTimelineForClaudeMd(result.content[0].text);
+      writeClaudeMdToFolder(folderPath, formatted);
+
+      logger.debug('FOLDER_INDEX', 'Updated CLAUDE.md', { folderPath });
+    } catch (error) {
+      logger.warn('FOLDER_INDEX', 'Failed to update CLAUDE.md', { folderPath }, error as Error);
+    }
+  }
+}
+```
+
+### Verification Checklist
+- [ ] `updateFolderClaudeMdFiles` function added
+- [ ] Takes only `filePaths`, `project`, `port` (no workspacePath)
+- [ ] Extracts folder paths from absolute file paths
+- [ ] Uses `writeClaudeMdToFolder` for atomic writes
+- [ ] Build passes: `npm run build`
+
+---
+
+## Phase 3: Update ResponseProcessor Integration
+
+### What to Implement
+
+Simplify the call site in `src/services/worker/agents/ResponseProcessor.ts`.
+
+### Current Code (lines 274-298)
+```typescript
+// Update folder CLAUDE.md files for touched folders (fire-and-forget)
+const filesModified: string[] = [];
+const filesRead: string[] = [];
+
+for (const obs of observations) {
+  filesModified.push(...(obs.files_modified || []));
+  filesRead.push(...(obs.files_read || []));
+}
+
+// Get workspace path from project registry
+const registry = readCursorRegistry();
+const registryEntry = registry[session.project];
+
+if (registryEntry && (filesModified.length > 0 || filesRead.length > 0)) {
+  updateFolderClaudeMd(
+    registryEntry.workspacePath,
+    filesModified,
+    filesRead,
+    session.project,
+    getWorkerPort()
+  ).catch(error => {
+    logger.warn('FOLDER_INDEX', 'CLAUDE.md update failed (non-critical)', { project: session.project }, error as Error);
+  });
+}
+```
+
+### New Code
+```typescript
+// Update folder CLAUDE.md files for touched folders (fire-and-forget)
+const allFilePaths: string[] = [];
+for (const obs of observations) {
+  allFilePaths.push(...(obs.files_modified || []));
+  allFilePaths.push(...(obs.files_read || []));
+}
+
+if (allFilePaths.length > 0) {
+  updateFolderClaudeMdFiles(
+    allFilePaths,
+    session.project,
+    getWorkerPort()
+  ).catch(error => {
+    logger.warn('FOLDER_INDEX', 'CLAUDE.md update failed (non-critical)', { project: session.project }, error as Error);
+  });
+}
+```
+
+### Import Changes
+
+**Remove:**
+```typescript
+import { updateFolderClaudeMd, readCursorRegistry } from '../../integrations/CursorHooksInstaller.js';
+```
+
+**Add:**
+```typescript
+import { updateFolderClaudeMdFiles } from '../../../utils/claude-md-utils.js';
+```
+
+**Keep (if still needed for Cursor context):**
+```typescript
+import { updateCursorContextForProject } from '../../worker-service.js';
+```
+
+### Verification Checklist
+- [ ] Import updated to use `claude-md-utils.ts`
+- [ ] `readCursorRegistry` import removed (if no longer needed)
+- [ ] Call site simplified - no registry lookup
+- [ ] Fire-and-forget pattern preserved
+- [ ] Build passes: `npm run build`
+
+---
+
+## Phase 4: Clean Up CursorHooksInstaller
+
+### What to Implement
+
+Remove the extracted functions from `src/services/integrations/CursorHooksInstaller.ts`.
+
+### Functions to Remove
+- `updateFolderClaudeMd` (lines 128-199)
+- `formatTimelineForClaudeMd` (lines 221-295)
+- `replaceTaggedContent` (lines 300-321)
+- `writeFolderClaudeMd` (lines 326-353)
+
+### Verification Checklist
+- [ ] All 4 functions removed from CursorHooksInstaller.ts
+- [ ] No dangling references to removed functions
+- [ ] CursorHooksInstaller still exports what it needs for Cursor integration
+- [ ] Build passes: `npm run build`
+- [ ] Grep shows no references to old function locations
+
+---
+
+## Phase 5: Verification
+
+### Build Check
+```bash
+npm run build
+```
+
+### Anti-Pattern Grep (should find NOTHING in CursorHooksInstaller)
+```bash
+grep -n "updateFolderClaudeMd\|formatTimelineForClaudeMd\|replaceTaggedContent\|writeFolderClaudeMd" src/services/integrations/CursorHooksInstaller.ts
+```
+
+### Correct Location Grep (should find in claude-md-utils)
+```bash
+grep -rn "updateFolderClaudeMdFiles\|writeClaudeMdToFolder\|formatTimelineForClaudeMd" src/utils/
+```
+
+### Integration Check
+```bash
+grep -n "updateFolderClaudeMdFiles" src/services/worker/agents/ResponseProcessor.ts
+```
+
+### No Cursor Registry Dependency
+```bash
+grep -n "readCursorRegistry" src/services/worker/agents/ResponseProcessor.ts
+# Should return nothing (or only for Cursor context, not folder index)
+```
+
+---
+
+## Summary
+
+**~150 lines moved** from CursorHooksInstaller.ts to claude-md-utils.ts with simplification:
+
+| Before | After |
+|--------|-------|
+| 4 functions in CursorHooksInstaller | 4 functions in claude-md-utils |
+| Requires Cursor registry lookup | Works with absolute paths directly |
+| `updateFolderClaudeMd(workspacePath, ...)` | `updateFolderClaudeMdFiles(filePaths, ...)` |
+| Coupled to Cursor integration | Independent utility |
+
+**Files Changed:**
+1. `src/utils/claude-md-utils.ts` - NEW (create)
+2. `src/services/worker/agents/ResponseProcessor.ts` - UPDATE (simplify call site)
+3. `src/services/integrations/CursorHooksInstaller.ts` - UPDATE (remove extracted functions)
@@ -0,0 +1,186 @@
+# Plan: Change Folder CLAUDE.md to Timeline Format
+
+## Goal
+
+Replace the simple table format in folder-level CLAUDE.md files with the timeline format used by search results.
+
+## Current vs Target Format
+
+### Current Format (Simple)
+```markdown
+# Recent Activity
+
+### Recent
+
+| Time | Type | Title |
+|------|------|-------|
+| 6:33pm | feature | Multiple CLAUDE.md files generated |
+| 6:32pm | feature | CLAUDE.md file successfully generated |
+```
+
+### Target Format (Timeline)
+```markdown
+# Recent Activity
+
+### Jan 4, 2026
+
+**src/services/worker/agents/ResponseProcessor.ts**
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #37110 | 6:35 PM | 🔴 | Folder CLAUDE.md updates moved from summary | ~85 |
+| #37109 | " | ✅ | ResponseProcessor.ts modified | ~92 |
+
+**General**
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #37108 | 6:33 PM | 🟣 | Multiple CLAUDE.md files generated | ~78 |
+```
+
+## Key Changes
+
+1. **Group by date** - Use `### Jan 4, 2026` instead of `### Recent`
+2. **Group by file within each date** - Add `**filename**` headers
+3. **Expand columns** - Add ID and Read columns: `| ID | Time | T | Title | Read |`
+4. **Use type emojis** - Use `🔴` `🟣` `✅` etc. instead of text
+5. **Show ditto marks** - Use `"` for repeated times
+
+---
+
+## Phase 1: Refactor formatTimelineForClaudeMd
+
+**File:** `src/utils/claude-md-utils.ts`
+
+**Tasks:**
+
+1. Add imports from shared utilities:
+   ```typescript
+   import { formatDate, formatTime, extractFirstFile, estimateTokens, groupByDate } from '../shared/timeline-formatting.js';
+   import { ModeManager } from '../services/domain/ModeManager.js';
+   ```
+
+2. Replace `formatTimelineForClaudeMd()` (lines 78-151) with new implementation that:
+   - Parses API response to extract full observation data (id, time, type emoji, title, files)
+   - Groups observations by date using `groupByDate()`
+   - Within each date, groups by file using a Map
+   - Renders file sections with `**filename**` headers
+   - Uses search table format: `| ID | Time | T | Title | Read |`
+   - Uses ditto marks for repeated times
+
+**Pattern to Copy From:** `src/services/worker/search/ResultFormatter.ts` lines 56-108
+
+**Key APIs:**
+- `groupByDate(items, getDate)` - from `src/shared/timeline-formatting.ts:104-127`
+- `formatTime(epoch)` - from `src/shared/timeline-formatting.ts:46-53`
+- `formatDate(epoch)` - from `src/shared/timeline-formatting.ts:59-66`
+- `extractFirstFile(filesModified, cwd)` - from `src/shared/timeline-formatting.ts:81-84`
+- `estimateTokens(text)` - from `src/shared/timeline-formatting.ts:89-92`
+- `ModeManager.getInstance().getTypeIcon(type)` - from `src/services/domain/ModeManager.ts`
+
+**Verification:**
+1. Run `npm run build` - no errors
+2. Restart worker: `npm run worker:restart`
+3. Make a test edit to trigger observation
+4. Check generated CLAUDE.md files for new format
+
+---
+
+## Phase 2: Parse Full Observation Data from API
+
+**Context:** The current regex parsing extracts only time, type emoji, and title. Need to also extract:
+- Observation ID (for `#123` column)
+- File path (from files_modified in API response, for grouping)
+- Token estimate (for `Read` column)
+
+**Challenge:** The current API returns formatted text, not structured data. We need to:
+1. Parse the existing text format more thoroughly, OR
+2. Use a different API endpoint that returns JSON
+
+**Decision Point:** Check what data the `/api/search/by-file` endpoint returns. If it returns structured JSON with observations, use that. Otherwise, enhance parsing.
+
+**Investigation Required:**
+- Read `src/services/worker/http/routes/SearchRoutes.ts` to see by-file response format
+- Determine if we can access raw observation data or just formatted text
+
+**Verification:**
+- Confirm API response structure
+- Update parsing to extract all needed fields
+
+---
+
+## Phase 3: Integrate File-Based Grouping
+
+**File:** `src/utils/claude-md-utils.ts`
+
+**Tasks:**
+
+1. Create helper to group by file:
+   ```typescript
+   function groupByFile(observations: ParsedObservation[]): Map<string, ParsedObservation[]> {
+     const byFile = new Map<string, ParsedObservation[]>();
+     for (const obs of observations) {
+       const file = obs.file || 'General';
+       if (!byFile.has(file)) byFile.set(file, []);
+       byFile.get(file)!.push(obs);
+     }
+     return byFile;
+   }
+   ```
+
+2. Render with file sections:
+   ```typescript
+   for (const [file, fileObs] of resultsByFile) {
+     lines.push(`**${file}**`);
+     lines.push(`| ID | Time | T | Title | Read |`);
+     lines.push(`|----|------|---|-------|------|`);
+     // render rows with ditto marks
+   }
+   ```
+
+**Pattern to Copy From:** `ResultFormatter.formatSearchResults()` lines 60-108
+
+**Verification:**
+- Generated CLAUDE.md shows file grouping
+- Files are displayed as relative paths when possible
+
+---
+
+## Phase 4: Final Verification
+
+**Checklist:**
+
+1. **Build passes:** `npm run build`
+2. **Worker restarts cleanly:** `npm run worker:restart`
+3. **Format matches target:**
+   - Date headers: `### Jan 4, 2026`
+   - File sections: `**filename**`
+   - Table columns: `| ID | Time | T | Title | Read |`
+   - Type emojis: `🔴` `🟣` `✅` not text
+   - Ditto marks: `"` for repeated times
+4. **Anti-pattern checks:**
+   - No hardcoded type maps (use ModeManager)
+   - No invented APIs
+   - Reuses existing formatters from shared utils
+5. **Graceful degradation:** Empty results still show `*No recent activity*`
+
+---
+
+## Files to Modify
+
+| File | Change |
+|------|--------|
+| `src/utils/claude-md-utils.ts` | Replace `formatTimelineForClaudeMd()` with timeline format |
+
+## Files to Read (Patterns to Copy)
+
+| File | Pattern |
+|------|---------|
+| `src/services/worker/search/ResultFormatter.ts:56-108` | Date/file grouping logic |
+| `src/shared/timeline-formatting.ts` | All formatting utilities |
+| `src/services/domain/ModeManager.ts` | Type icon lookup |
+
+## Anti-Patterns to Avoid
+
+- ❌ Creating new hardcoded type→emoji maps (use ModeManager)
+- ❌ Parsing dates manually (use shared formatters)
+- ❌ Skipping the existing groupByDate utility
+- ❌ Not handling ditto marks for repeated times
@@ -0,0 +1,356 @@
+# Execution Plan: Intentional Patterns Validation Actions
+
+**Created:** 2026-01-13
+**Source:** `docs/reports/intentional-patterns-validation.md`
+**Target:** `src/services/worker-service.ts` and related files
+
+---
+
+## Phase 0: Documentation Discovery (COMPLETED)
+
+### Evidence Gathered
+
+**Files Analyzed:**
+- `docs/reports/intentional-patterns-validation.md` - Pattern verdicts and recommendations
+- `docs/reports/nonsense-logic.md` - Original 23 issues identified
+- `.claude/plans/cleanup-worker-service-nonsense-logic.md` - Existing cleanup plan
+- `src/services/worker-service.ts` (813 lines) - Current state
+
+**Current State:**
+- File has been reduced from 1445 lines to 813 lines in prior refactoring
+- `runInteractiveSetup` still exists at line 439 (~200 lines of dead code)
+- Re-export at line 78: `export { updateCursorContextForProject };`
+- MCP version hardcoded "1.0.0" at line 159
+- Fallback agents set at lines 144-146 without verification
+- Unused imports: `fs`, `spawn`, `homedir`, `readline` at lines 13-17
+
+**Allowed APIs (from validation report):**
+- Exit code 0 pattern: **KEEP** (documented Windows Terminal workaround)
+- `as Error` casts: **KEEP** (documented project policy)
+- Dual init tracking: **KEEP** (serves async + sync callers)
+- Signal handler ref pattern: **KEEP** (standard JS mutable state sharing)
+- Empty MCP capabilities: **KEEP** (correct per MCP spec)
+
+**Actions Required:**
+| Pattern | Action | Priority |
+|---------|--------|----------|
+| Re-export for circular import | Remove (no actual circular dep) | LOW |
+| Fallback agent without check | Add availability verification | HIGH |
+| MCP version hardcoded | Update to use package.json | LOW |
+| Dead code `runInteractiveSetup` | Delete (~200 lines) | HIGH |
+| Unused imports | Delete | LOW |
+
+---
+
+## Phase 1: Delete Dead Code (HIGH PRIORITY)
+
+### 1.1 Delete `runInteractiveSetup` Function
+
+**What:** Delete lines 435-639 (approximately 200 lines)
+**File:** `src/services/worker-service.ts`
+
+**Location confirmed:** Line 439 starts `async function runInteractiveSetup(): Promise<number>`
+
+**Steps:**
+1. Read worker-service.ts lines 435-650 to find exact boundaries
+2. Delete the section comment and entire function
+3. Run build to verify no compile errors
+
+**Verification:**
+```bash
+grep -n "runInteractiveSetup" src/services/worker-service.ts
+# Expected: No output (function deleted)
+npm run build
+# Expected: No errors
+```
+
+### 1.2 Remove Unused Imports
+
+**What:** Delete imports only used by dead code
+**Lines to delete:** 13-17 (check each)
+
+**Current imports to remove:**
+```typescript
+import * as fs from 'fs';              // Line 13 - UNUSED (namespace never accessed)
+import { spawn } from 'child_process'; // Line 14 - UNUSED (MCP uses StdioClientTransport)
+import { homedir } from 'os';          // Line 15 - Only in dead code
+import * as readline from 'readline';  // Line 17 - Only in dead code
+```
+
+**Keep:**
+```typescript
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'fs';  // Line 16 - CHECK
+```
+
+**Steps:**
+1. After deleting `runInteractiveSetup`, grep each import
+2. Delete any with zero usages
+3. Run build to verify
+
+**Verification:**
+```bash
+grep -n "^import \* as fs" src/services/worker-service.ts
+grep -n "import { spawn }" src/services/worker-service.ts
+# Expected: No output
+npm run build
+```
+
+### 1.3 Remove Unused CursorHooksInstaller Imports
+
+**After deleting dead code, check:**
+```typescript
+import {
+  updateCursorContextForProject,  // KEEP (re-exported)
+  handleCursorCommand,            // KEEP (used in main)
+  detectClaudeCode,               // DELETE (only in dead code)
+  findCursorHooksDir,             // DELETE (only in dead code)
+  installCursorHooks,             // DELETE (only in dead code)
+  configureCursorMcp              // DELETE (only in dead code)
+} from './integrations/CursorHooksInstaller.js';
+```
+
+**Verification:**
+```bash
+grep "detectClaudeCode\|findCursorHooksDir\|installCursorHooks\|configureCursorMcp" src/services/worker-service.ts
+# Expected: Only import line (which gets trimmed)
+```
+
+---
+
+## Phase 2: Fix Fallback Agent Oversight (HIGH PRIORITY)
+
+### 2.1 Add SDKAgent Availability Check
+
+**Problem:** Lines 144-146 set Claude SDK as fallback without verifying it's configured
+```typescript
+this.geminiAgent.setFallbackAgent(this.sdkAgent);
+this.openRouterAgent.setFallbackAgent(this.sdkAgent);
+```
+
+**Risk:** User chooses Gemini because they lack Claude credentials → transient Gemini error → fallback to Claude SDK → cascading failure
+
+**Solution Options:**
+
+**Option A: Add isConfigured() method to SDKAgent**
+1. Add method to SDKAgent that checks for valid Claude SDK credentials
+2. Only set fallback if `sdkAgent.isConfigured()` returns true
+3. Log warning when fallback unavailable
+
+**Pattern to follow (from SDKAgent.ts constructor):**
+```typescript
+// Check if Claude SDK can be initialized
+public isConfigured(): boolean {
+  // Claude SDK uses subprocess, check if claude command exists
+  try {
+    // Check for ANTHROPIC_API_KEY or claude CLI availability
+    return !!process.env.ANTHROPIC_API_KEY || this.checkClaudeCliAvailable();
+  } catch {
+    return false;
+  }
+}
+```
+
+**Option B: Document limitation (minimal fix)**
+Add comment explaining the risk:
+```typescript
+// NOTE: Fallback to Claude SDK may fail if user lacks Claude credentials
+// Consider adding availability check in future (Issue #XXX)
+this.geminiAgent.setFallbackAgent(this.sdkAgent);
+```
+
+**Recommended: Option A**
+
+**Steps:**
+1. Read SDKAgent.ts to understand initialization pattern
+2. Add `isConfigured()` method that checks Claude CLI/credentials
+3. Update worker-service.ts to conditionally set fallback
+4. Add warning log when fallback unavailable
+5. Run tests
+
+**Verification:**
+```bash
+grep -n "isConfigured" src/services/worker/SDKAgent.ts
+# Expected: Method definition
+grep -n "setFallbackAgent" src/services/worker-service.ts
+# Expected: Conditional calls with isConfigured check
+npm test
+```
+
+---
+
+## Phase 3: Remove Unnecessary Re-Export (LOW PRIORITY)
+
+### 3.1 Fix Misleading Re-Export
+
+**Current (worker-service.ts:77-78):**
+```typescript
+// Re-export updateCursorContextForProject for SDK agents
+export { updateCursorContextForProject };
+```
+
+**Issue:** Comment implies avoiding circular import, but investigation found NO circular dependency exists.
+
+**Import chain:**
+```
+CursorHooksInstaller.ts (defines) → worker-service.ts (imports, re-exports) → ResponseProcessor.ts (imports)
+```
+
+**ResponseProcessor.ts could import directly from CursorHooksInstaller.ts**
+
+**Options:**
+1. **Remove re-export entirely** - Update ResponseProcessor.ts to import from CursorHooksInstaller directly
+2. **Fix comment** - Update to reflect actual reason (API surface simplification)
+
+**Recommended: Option 1 (cleaner)**
+
+**Steps:**
+1. Update `src/services/worker/agents/ResponseProcessor.ts`:
+   - Change: `import { updateCursorContextForProject } from '../../worker-service.js';`
+   - To: `import { updateCursorContextForProject } from '../../integrations/CursorHooksInstaller.js';`
+2. Delete re-export from worker-service.ts (lines 77-78)
+3. Run build to verify
+
+**Verification:**
+```bash
+grep -n "export { updateCursorContextForProject" src/services/worker-service.ts
+# Expected: No output
+grep -n "updateCursorContextForProject" src/services/worker/agents/ResponseProcessor.ts
+# Expected: Import from CursorHooksInstaller
+npm run build
+```
+
+---
+
+## Phase 4: Update MCP Version (LOW PRIORITY)
+
+### 4.1 Use Package Version for MCP Client
+
+**Current (worker-service.ts:157-160):**
+```typescript
+this.mcpClient = new Client({
+  name: 'worker-search-proxy',
+  version: '1.0.0'  // Hardcoded, should match package.json (9.0.4)
+}, { capabilities: {} });
+```
+
+**Also affects (from report):**
+- `src/services/sync/ChromaSync.ts:126-131`
+- MCP server (separate file)
+
+**Pattern to follow:**
+```typescript
+import { version } from '../../package.json' assert { type: 'json' };
+
+this.mcpClient = new Client({
+  name: 'worker-search-proxy',
+  version: version
+}, { capabilities: {} });
+```
+
+**Alternative (if JSON import not supported):**
+```typescript
+import { readFileSync } from 'fs';
+const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+
+this.mcpClient = new Client({
+  name: 'worker-search-proxy',
+  version: pkg.version
+}, { capabilities: {} });
+```
+
+**Steps:**
+1. Check if JSON import assertion works in project
+2. Update worker-service.ts MCP client initialization
+3. Update ChromaSync.ts similarly
+4. Run build to verify
+
+**Verification:**
+```bash
+grep -n "version: '1.0.0'" src/services/worker-service.ts src/services/sync/ChromaSync.ts
+# Expected: No output
+npm run build
+```
+
+### 4.2 Add MCP Capabilities Comment
+
+**Current:**
+```typescript
+}, { capabilities: {} });
+```
+
+**Add clarifying comment:**
+```typescript
+}, {
+  // MCP spec: Clients accept all server capabilities; no declaration needed
+  capabilities: {}
+});
+```
+
+---
+
+## Phase 5: Verification
+
+### 5.1 Build Check
+```bash
+npm run build
+```
+**Expected:** No TypeScript errors
+
+### 5.2 Test Suite
+```bash
+npm test
+```
+**Expected:** All tests pass
+
+### 5.3 Grep for Anti-Patterns
+```bash
+# Verify dead code removed
+grep -r "runInteractiveSetup" src/
+# Expected: No matches
+
+# Verify unused imports removed
+grep "import \* as fs from 'fs'" src/services/worker-service.ts
+# Expected: No match
+
+# Verify re-export removed
+grep "export { updateCursorContextForProject" src/services/worker-service.ts
+# Expected: No match
+
+# Verify fallback has check
+grep -A2 "setFallbackAgent" src/services/worker-service.ts
+# Expected: Conditional with isConfigured check
+```
+
+### 5.4 Runtime Check
+```bash
+npm run build-and-sync
+# Manually verify worker starts and basic operations work
+```
+
+---
+
+## Summary
+
+| Phase | Description | Lines Changed | Priority |
+|-------|-------------|---------------|----------|
+| Phase 1 | Delete dead code + imports | ~200 deleted | HIGH |
+| Phase 2 | Add fallback verification | ~10 added | HIGH |
+| Phase 3 | Remove re-export | ~5 changed | LOW |
+| Phase 4 | Update MCP version | ~3 changed | LOW |
+| Phase 5 | Verification | N/A | N/A |
+
+**Execution Order:** Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5
+
+**Note:** Each phase should be followed by verification (build + test) before proceeding.
+
+---
+
+## Patterns Confirmed KEEP (No Action)
+
+These patterns were validated as intentional:
+
+1. **Exit code 0 always** - Windows Terminal tab accumulation workaround (commit 222a73da)
+2. **`as Error` casts** - Documented project policy with anti-pattern detection
+3. **Dual init tracking** - Promise for async, flag for sync callers
+4. **Signal handler ref pattern** - Standard JS mutable state sharing
+5. **Empty MCP capabilities** - Correct per MCP client spec
@@ -0,0 +1,144 @@
+# Plan: Address PR #610 Review Issues
+
+## Overview
+This plan addresses the issues identified in the PR review for PR #610 "fix: Update hooks for Claude Code 2.1.0/1 - SessionStart no longer shows user messages".
+
+## Phase 0: Verification and Discovery
+
+### 0.1 Verify Test Failure
+- **File**: `tests/hook-constants.test.ts`
+- **Issue**: Lines 61-63 test for `HOOK_EXIT_CODES.USER_MESSAGE_ONLY` which was removed
+- **Verification**: Run `bun test tests/hook-constants.test.ts` to confirm failure
+
+### 0.2 Verify No Code References USER_MESSAGE_ONLY
+- **Finding**: Grep found references only in:
+  - `tests/hook-constants.test.ts` (test file - needs fix)
+  - `src/services/CLAUDE.md` (memory context - auto-generated, not code)
+  - `plugin/scripts/CLAUDE.md` (memory context - auto-generated, not code)
+- **Conclusion**: Only the test file needs updating; CLAUDE.md files are memory records
+
+### 0.3 Verify CLAUDE.md Files Are Legitimate
+- **Clarification**: The PR reviewer mentioned "user-specific CLAUDE.md files starting with ~/"
+- **Finding**: All CLAUDE.md files in the commit are within the repository (`docs/`, `src/`, `plugin/`)
+- **Conclusion**: These are legitimate in-repo context files, not user-specific paths
+
+---
+
+## Phase 1: Fix Test File (REQUIRED)
+
+### Task 1.1: Remove USER_MESSAGE_ONLY Test
+**File**: `tests/hook-constants.test.ts`
+**Action**: Delete lines 61-63 that test for the removed constant
+
+```typescript
+// DELETE THESE LINES:
+it('should define USER_MESSAGE_ONLY exit code', () => {
+  expect(HOOK_EXIT_CODES.USER_MESSAGE_ONLY).toBe(3);
+});
+```
+
+### Task 1.2: Add Test for BLOCKING_ERROR
+**File**: `tests/hook-constants.test.ts`
+**Action**: Add test for the new `BLOCKING_ERROR` constant (exit code 2) that replaced it
+
+```typescript
+// ADD THIS TEST:
+it('should define BLOCKING_ERROR exit code', () => {
+  expect(HOOK_EXIT_CODES.BLOCKING_ERROR).toBe(2);
+});
+```
+
+### Verification
+- Run `bun test tests/hook-constants.test.ts`
+- Expect: All tests pass
+
+---
+
+## Phase 2: Documentation Consistency (NICE TO HAVE)
+
+### Issue
+Three similar notes about Claude Code 2.1.0 have slightly different wording:
+
+1. `docs/public/architecture/hooks.mdx:254`:
+   > "SessionStart hooks no longer display any user-visible messages. Context is still injected via `hookSpecificOutput.additionalContext` but users don't see startup output in the UI."
+
+2. `docs/public/hooks-architecture.mdx:31`:
+   > "SessionStart hooks no longer display any user-visible messages. Context is silently injected via `hookSpecificOutput.additionalContext`."
+
+3. `docs/public/hooks-architecture.mdx:441`:
+   > "SessionStart hooks output is never displayed to users. Context is injected silently via `hookSpecificOutput.additionalContext`."
+
+### Task 2.1: Standardize Note Wording
+**Action**: Use consistent wording across all three locations
+
+**Standard text**:
+```
+As of Claude Code 2.1.0 (ultrathink update), SessionStart hooks no longer display user-visible messages. Context is silently injected via `hookSpecificOutput.additionalContext`.
+```
+
+### Files to Update
+1. `docs/public/architecture/hooks.mdx:253-255` - Update Note block
+2. `docs/public/hooks-architecture.mdx:30-32` - Update Note block
+3. `docs/public/hooks-architecture.mdx:440-442` - Update Note block
+
+### Verification
+- Grep for the standard text in all three files
+- Visual review of documentation
+
+---
+
+## Phase 3: Code Quality Improvements (OPTIONAL)
+
+### Issue 3.1: Hardcoded Promotional Message
+**File**: `src/hooks/context-hook.ts:66-68`
+**Current code**:
+```typescript
+const enhancedContext = `${text}
+
+Access 300k tokens of past research & decisions for just 19,008t. Use MCP search tools to access memories by ID.`;
+```
+
+### Options
+1. **Leave as-is**: The token count is a rough estimate and doesn't need to be exact
+2. **Make configurable**: Add to settings (over-engineering for this use case)
+3. **Remove hardcoded numbers**: Use relative language instead
+
+### Recommendation
+Leave as-is for now. The token counts are marketing copy, not critical functionality. Creating a PR just for this adds unnecessary complexity.
+
+---
+
+## Phase 4: Final Verification
+
+### 4.1 Run Full Test Suite
+```bash
+bun test
+```
+
+### 4.2 Build Verification
+```bash
+npm run build
+```
+
+### 4.3 Grep Verification
+```bash
+grep -r "USER_MESSAGE_ONLY" src/ --include="*.ts" --include="*.js"
+```
+Expected: No results (CLAUDE.md files excluded as they're memory records)
+
+---
+
+## Summary
+
+| Phase | Priority | Effort | Description |
+|-------|----------|--------|-------------|
+| 1 | REQUIRED | 5 min | Fix test file - remove USER_MESSAGE_ONLY test, add BLOCKING_ERROR test |
+| 2 | Nice to have | 10 min | Standardize documentation note wording |
+| 3 | Skip | - | Hardcoded token counts are fine as-is |
+| 4 | REQUIRED | 5 min | Run tests and build to verify |
+
+## Expected Outcome
+- All tests pass
+- Build succeeds
+- No code references to removed USER_MESSAGE_ONLY constant
+- Documentation uses consistent wording (if Phase 2 is done)
@@ -0,0 +1,223 @@
+# Plan: PR #628 Polish Items
+
+**PR**: #628 - Windows Terminal Tab Accumulation & Windows 11 Compatibility
+**Status**: APPROVED by 3 reviewers with minor suggestions
+**Branch**: `feature/no-more-hook-files`
+
+---
+
+## Phase 0: Documentation Discovery (Completed by Orchestrator)
+
+### Allowed APIs and Patterns
+
+**Exit Code Constants** - `src/shared/hook-constants.ts:18-23`:
+```typescript
+export const HOOK_EXIT_CODES = {
+  SUCCESS: 0,
+  FAILURE: 1,
+  BLOCKING_ERROR: 2,
+} as const;
+```
+
+**Timeout Constants** - `src/shared/hook-constants.ts:1-8`:
+```typescript
+export const HOOK_TIMEOUTS = {
+  DEFAULT: 300000,
+  HEALTH_CHECK: 30000,
+  WORKER_STARTUP_WAIT: 1000,
+  WORKER_STARTUP_RETRIES: 300,
+  PRE_RESTART_SETTLE_DELAY: 2000,
+  WINDOWS_MULTIPLIER: 1.5
+} as const;
+```
+
+**Platform Timeout Function** - `src/services/infrastructure/ProcessManager.ts:70-73`:
+```typescript
+export function getPlatformTimeout(baseMs: number): number {
+  const WINDOWS_MULTIPLIER = 2.0;
+  return process.platform === 'win32' ? Math.round(baseMs * WINDOWS_MULTIPLIER) : baseMs;
+}
+```
+
+**Migration Guide Pattern** - `docs/public/architecture/pm2-to-bun-migration.mdx`:
+- Uses MDX format with frontmatter
+- Starts with `<Note>` for historical context
+- Uses `<AccordionGroup>` for before/after comparisons
+- Includes executive summary, key benefits, migration impact sections
+
+**Exit Code Documentation** - `private/context/claude-code/exit-codes.md`:
+- Defines exit code 0, 2, and other behaviors
+- Per-hook event behavior table
+
+### Files to Modify
+
+| File | Change | Lines |
+|------|--------|-------|
+| `src/services/infrastructure/ProcessManager.ts` | Add POWERSHELL_TIMEOUT constant, reduce from 60000 to 10000 | 93, 123, 175, 241 |
+| `src/shared/hook-constants.ts` | Add POWERSHELL_TIMEOUT constant | After line 8 |
+| `CLAUDE.md` | Document exit code strategy | Architecture section |
+
+### Anti-Patterns to Avoid
+
+- DO NOT invent new exit code values (only 0, 1, 2 exist)
+- DO NOT change Windows multiplier (1.5x in hooks, 2.0x in ProcessManager - they serve different purposes)
+- DO NOT add upper bound PID validation (not in existing pattern, reviewers marked as "nice to have")
+- DO NOT create migration guide for Cursor (shell scripts still exist in cursor-hooks/, not removed)
+
+---
+
+## Phase 1: Extract PowerShell Timeout Constant
+
+### What to Implement
+
+Add a `POWERSHELL_TIMEOUT` constant to centralize the magic number `60000` and reduce to `10000` (10 seconds) as recommended by reviewers.
+
+### Documentation References
+
+1. Copy constant pattern from `src/shared/hook-constants.ts:1-8`
+2. Copy usage pattern from `src/services/infrastructure/ProcessManager.ts:93`
+
+### Implementation Steps
+
+1. **Add constant to hook-constants.ts** after line 8:
+   ```typescript
+   POWERSHELL_COMMAND: 10000,     // PowerShell process enumeration (10s - typically completes in <1s)
+   ```
+
+2. **Import and use in ProcessManager.ts**:
+   - Import `HOOK_TIMEOUTS` from `../../shared/hook-constants.js`
+   - Replace `{ timeout: 60000 }` with `{ timeout: HOOK_TIMEOUTS.POWERSHELL_COMMAND }` at lines 93, 123, 175, 241
+
+### Verification Checklist
+
+- [ ] `grep -n "60000" src/services/infrastructure/ProcessManager.ts` returns 0 matches
+- [ ] `grep -n "POWERSHELL_COMMAND" src/services/infrastructure/ProcessManager.ts` returns 4 matches
+- [ ] `npm run build` succeeds
+- [ ] `npm test` passes (22/22 PowerShell tests still pass)
+
+### Anti-Pattern Guards
+
+- DO NOT use `getPlatformTimeout()` for PowerShell commands (they already run only on Windows)
+- DO NOT change timeout values in other files (only ProcessManager.ts uses PowerShell)
+
+---
+
+## Phase 2: Document Exit Code Strategy in CLAUDE.md
+
+### What to Implement
+
+Add an "Exit Code Strategy" section to the main CLAUDE.md to explain the graceful exit philosophy adopted in this PR.
+
+### Documentation References
+
+1. Copy exit code definitions from `private/context/claude-code/exit-codes.md`
+2. Follow format of existing CLAUDE.md sections
+
+### Implementation Steps
+
+1. **Add section after "File Locations"** in `/Users/alexnewman/Scripts/claude-mem/CLAUDE.md`:
+
+```markdown
+## Exit Code Strategy
+
+Claude-mem hooks use specific exit codes per Claude Code's hook contract:
+
+- **Exit 0**: Success or graceful shutdown (Windows Terminal closes tabs)
+- **Exit 1**: Non-blocking error (stderr shown to user, continues)
+- **Exit 2**: Blocking error (stderr fed to Claude for processing)
+
+**Philosophy**: Worker/hook errors exit with code 0 to prevent Windows Terminal tab accumulation. The wrapper/plugin layer handles restart logic. ERROR-level logging is maintained for diagnostics.
+
+See `private/context/claude-code/exit-codes.md` for full hook behavior matrix.
+```
+
+### Verification Checklist
+
+- [ ] `grep -n "Exit Code Strategy" CLAUDE.md` returns 1 match
+- [ ] Section appears after "File Locations" section
+- [ ] No duplicate sections added
+
+### Anti-Pattern Guards
+
+- DO NOT copy the full exit-codes.md table (keep it brief, reference the source)
+- DO NOT change actual exit code behavior in code files
+
+---
+
+## Phase 3: Update Tests for New Timeout Constant
+
+### What to Implement
+
+Add test coverage for the new `POWERSHELL_COMMAND` timeout constant.
+
+### Documentation References
+
+1. Copy test pattern from `tests/hook-constants.test.ts:26-48`
+
+### Implementation Steps
+
+1. **Add test to hook-constants.test.ts** after line 42:
+   ```typescript
+   test('POWERSHELL_COMMAND timeout is 10000ms', () => {
+     expect(HOOK_TIMEOUTS.POWERSHELL_COMMAND).toBe(10000);
+   });
+   ```
+
+### Verification Checklist
+
+- [ ] `npm test -- tests/hook-constants.test.ts` passes
+- [ ] New test appears in test output
+- [ ] All 22 PowerShell parsing tests still pass
+
+### Anti-Pattern Guards
+
+- DO NOT modify PowerShell parsing tests (they test parsing, not timeouts)
+- DO NOT add integration tests for actual PowerShell execution (out of scope)
+
+---
+
+## Phase 4: Final Verification
+
+### Verification Checklist
+
+1. **Build passes**: `npm run build`
+2. **All tests pass**: `npm test`
+3. **No magic numbers remain**: `grep -rn "60000" src/services/infrastructure/ProcessManager.ts` returns 0
+4. **Exit code documentation exists**: `grep -n "Exit Code Strategy" CLAUDE.md` returns 1
+5. **Constant is used**: `grep -rn "POWERSHELL_COMMAND" src/` returns multiple matches
+
+### Anti-Pattern Grep Checks
+
+- [ ] `grep -rn "timeout: 60000" src/` returns 0 matches (no hardcoded 60s timeouts in ProcessManager)
+- [ ] `grep -rn "process.exit(3)" src/` returns 0 matches (exit code 3 not used)
+
+### Commit Message Template
+
+```
+polish: extract PowerShell timeout constant and document exit code strategy
+
+- Extract magic number 60000ms to HOOK_TIMEOUTS.POWERSHELL_COMMAND (10000ms)
+- Reduce PowerShell timeout from 60s to 10s per review feedback
+- Document exit code strategy in CLAUDE.md
+- Add test coverage for new constant
+
+Addresses review feedback from PR #628
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+```
+
+---
+
+## Summary
+
+| Phase | Description | Files Changed | Verification |
+|-------|-------------|---------------|--------------|
+| 0 | Documentation Discovery | N/A | Patterns identified |
+| 1 | Extract PowerShell timeout | hook-constants.ts, ProcessManager.ts | grep + build + test |
+| 2 | Document exit strategy | CLAUDE.md | grep |
+| 3 | Add test coverage | hook-constants.test.ts | npm test |
+| 4 | Final verification | N/A | All checks pass |
+
+**Estimated Changes**: ~20 lines added/modified across 4 files
+**Risk Level**: Low (constants extraction, documentation only)
+**Breaking Changes**: None
@@ -0,0 +1,394 @@
+# Plan: Remove Worker Start Calls - In-Process Architecture
+
+## Problem Statement
+
+Current architecture has problematic spawn patterns:
+1. `hooks.json` calls `worker-service.cjs start` which spawns a daemon
+2. Spawning is buggy on Windows - **HARD RULE: NO SPAWN**
+3. `user-message` hook is deprecated
+4. `smart-install` was supposed to chain: `smart-install && stop && context`
+
+## Target Architecture
+
+**NO SPAWN - Worker runs in-process within hook command**
+
+```
+SessionStart:
+  smart-install && stop && context
+```
+
+Flow:
+1. `smart-install` - Install dependencies if needed
+2. `stop` - Kill any existing worker (clean slate)
+3. `context` - Hook starts worker IN-PROCESS, becomes the worker
+
+**Key insight:** The first hook that needs the worker **becomes** the worker. No spawn, no daemon. The hook process IS the worker process.
+
+---
+
+## Current vs Target hooks.json
+
+### Current (BROKEN)
+```json
+"SessionStart": [
+  { "hooks": [
+    { "command": "node smart-install.js" },
+    { "command": "bun worker-service.cjs start" },      // REMOVE - spawn
+    { "command": "bun worker-service.cjs hook ... context" },
+    { "command": "bun worker-service.cjs hook ... user-message" }  // REMOVE - deprecated
+  ]}
+]
+```
+
+### Target
+```json
+"SessionStart": [
+  { "hooks": [
+    { "command": "node smart-install.js && bun worker-service.cjs stop && bun worker-service.cjs hook claude-code context" }
+  ]}
+]
+```
+
+---
+
+## Files Involved
+
+| File | Changes |
+|------|---------|
+| `plugin/hooks/hooks.json` | Restructure to chained commands, remove start/user-message |
+| `src/services/worker-service.ts` | `hook` case: start worker in-process if not running |
+| `src/cli/handlers/*.ts` | May need adjustment for in-process execution |
+| `src/shared/worker-utils.ts` | `ensureWorkerRunning()` → adapt for in-process |
+
+---
+
+## Phase 0: Documentation Discovery
+
+### Available APIs
+
+**From `src/services/infrastructure/HealthMonitor.ts`:**
+- `isPortInUse(port): Promise<boolean>`
+- `waitForHealth(port, timeoutMs): Promise<boolean>`
+- `httpShutdown(port): Promise<void>`
+
+**From `src/services/worker-service.ts`:**
+- `WorkerService` class - the actual worker
+- `stop` command - shuts down worker via HTTP
+- `--daemon` case - starts WorkerService (currently only used after spawn)
+
+**BANNED (spawn patterns):**
+- ~~`spawnDaemon()`~~ - NO SPAWN
+- ~~`fork()`~~ - NO SPAWN
+- ~~`spawn()` with detached~~ - NO SPAWN
+
+### Anti-Patterns
+- **NO SPAWN** - Hard rule, Windows buggy
+- No `restart` command - removed for same reason
+- No detached processes
+
+---
+
+## Phase 1: Modify `hook` Case for In-Process Worker
+
+### Location
+`src/services/worker-service.ts:564-576`
+
+### Current Code
+```typescript
+case 'hook': {
+  const platform = process.argv[3];
+  const event = process.argv[4];
+  if (!platform || !event) {
+    console.error('Usage: claude-mem hook <platform> <event>');
+    process.exit(1);
+  }
+  const { hookCommand } = await import('../cli/hook-command.js');
+  await hookCommand(platform, event);
+  break;
+}
+```
+
+### Target Code
+```typescript
+case 'hook': {
+  const platform = process.argv[3];
+  const event = process.argv[4];
+  if (!platform || !event) {
+    console.error('Usage: claude-mem hook <platform> <event>');
+    process.exit(1);
+  }
+
+  // Check if worker already running (port in use = valid, another process has it)
+  const portInUse = await isPortInUse(port);
+  if (portInUse) {
+    // Port in use - either healthy worker or something else
+    // Proceed with hook via HTTP to existing worker
+    const { hookCommand } = await import('../cli/hook-command.js');
+    await hookCommand(platform, event);
+    break;
+  }
+
+  // Port free - start worker IN THIS PROCESS (no spawn!)
+  logger.info('SYSTEM', 'Starting worker in-process for hook');
+  const worker = new WorkerService();
+
+  // Start worker (non-blocking, returns when server listening)
+  await worker.start();
+
+  // Now execute hook logic - worker is running in this process
+  // Can call handler directly (in-process) or via HTTP to self
+  const { hookCommand } = await import('../cli/hook-command.js');
+  await hookCommand(platform, event);
+
+  // DON'T exit - this process IS the worker now
+  // Worker stays alive serving requests
+  break;
+}
+```
+
+### Key Behavior
+- If port in use → hook runs via HTTP to existing worker, then exits
+- If port free → start worker in-process, run hook, process stays alive as worker
+
+### Verification
+- [ ] Stop worker, run hook command → should start worker and stay alive
+- [ ] Worker already running, run hook command → should complete and exit
+- [ ] `lsof -i :37777` shows hook process IS the worker
+
+---
+
+## Phase 2: Update hooks.json - Chained Commands
+
+### Location
+`plugin/hooks/hooks.json`
+
+### Target Structure
+```json
+{
+  "description": "Claude-mem memory system hooks",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/smart-install.js\" && bun \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" stop && bun \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code context",
+            "timeout": 300
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code session-init",
+            "timeout": 60
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code observation",
+            "timeout": 120
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code summarize",
+            "timeout": 120
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### Changes Summary
+1. SessionStart: Chain `smart-install && stop && context` in single command
+2. Remove `user-message` hook (deprecated)
+3. Remove all separate `start` commands
+4. Other hooks unchanged (just hook command, auto-starts if needed)
+
+### Verification
+- [ ] JSON valid: `cat plugin/hooks/hooks.json | jq .`
+- [ ] No `start` command: `grep -c '"start"' plugin/hooks/hooks.json` = 0
+- [ ] No `user-message`: `grep -c 'user-message' plugin/hooks/hooks.json` = 0
+
+---
+
+## Phase 3: Handle "Port In Use" Gracefully
+
+### Scenario
+Another process has port 37777 (not our worker). Hook should handle gracefully.
+
+### Current Behavior
+`ensureWorkerRunning()` polls for 15 seconds, then throws error.
+
+### Target Behavior
+If port in use but not healthy (not our worker):
+- Hook is "valid" - don't block Claude Code
+- Return graceful response (empty context, etc.)
+- Log warning for debugging
+
+### Location
+`src/shared/worker-utils.ts:117-141`
+
+### Changes
+```typescript
+export async function ensureWorkerRunning(): Promise<boolean> {
+  const port = getWorkerPort();
+
+  // Quick health check (2 seconds max)
+  try {
+    if (await isWorkerHealthy()) {
+      await checkWorkerVersion();
+      return true;  // Worker healthy
+    }
+  } catch (e) {
+    // Not healthy
+  }
+
+  // Port might be in use by something else
+  // Return false but don't throw - let caller decide
+  logger.warn('SYSTEM', 'Worker not healthy, hook will proceed gracefully');
+  return false;
+}
+```
+
+### Handler Updates
+Update handlers to handle `ensureWorkerRunning()` returning false:
+```typescript
+const workerReady = await ensureWorkerRunning();
+if (!workerReady) {
+  // Return graceful empty response
+  return { output: '', exitCode: HOOK_EXIT_CODES.SUCCESS };
+}
+```
+
+### Verification
+- [ ] Start non-worker process on 37777, run hook → completes gracefully
+- [ ] No 15-second hang when port blocked
+
+---
+
+## Phase 4: Remove Deprecated Code
+
+### Remove `user-message` Handler (if unused elsewhere)
+- [ ] Check if `user-message.ts` is used anywhere else
+- [ ] Remove from `src/cli/handlers/index.ts` if safe
+- [ ] Consider keeping file but removing from hooks.json only
+
+### Remove `start` Command (optional)
+The `start` command in worker-service.ts can stay for manual use:
+```bash
+bun worker-service.cjs start  # Manual start if needed
+```
+But it should NOT be called from hooks.json.
+
+### Verification
+- [ ] `npm run build` succeeds
+- [ ] No references to removed handlers in hooks.json
+
+---
+
+## Phase 5: Update Handler `ensureWorkerRunning()` Calls
+
+### Context
+Each handler currently calls `ensureWorkerRunning()` which polls for 15 seconds.
+
+With in-process architecture:
+- If hook started worker in-process → worker is THIS process, no HTTP needed
+- If worker already running → HTTP to existing worker
+
+### Decision
+**Keep handler calls** but modify `ensureWorkerRunning()` to:
+1. Return quickly if port is in use (assume valid)
+2. Return true if in-process worker (detect via global flag?)
+3. Graceful false return instead of throwing
+
+### Files
+- `src/cli/handlers/context.ts:15`
+- `src/cli/handlers/session-init.ts:15`
+- `src/cli/handlers/observation.ts:14`
+- `src/cli/handlers/summarize.ts:17`
+- `src/cli/handlers/file-edit.ts:15`
+
+### Verification
+- [ ] Handlers don't hang on port-in-use scenarios
+- [ ] In-process worker scenario works
+
+---
+
+## Phase 6: Final Verification
+
+### Tests
+- [ ] `bun test` - All tests pass
+- [ ] `npm run build-and-sync` - Build succeeds
+
+### Manual Tests
+
+**Test 1: Clean Start**
+```bash
+bun plugin/scripts/worker-service.cjs stop
+# Start new Claude Code session
+# Verify: context hook starts worker in-process
+# Verify: lsof -i :37777 shows the hook process
+```
+
+**Test 2: Worker Already Running**
+```bash
+bun plugin/scripts/worker-service.cjs stop
+bun plugin/scripts/worker-service.cjs hook claude-code context &
+# Wait for worker to start
+bun plugin/scripts/worker-service.cjs hook claude-code observation
+# Verify: observation hook exits after completing (doesn't stay alive)
+```
+
+**Test 3: Port Blocked**
+```bash
+bun plugin/scripts/worker-service.cjs stop
+nc -l 37777 &  # Block port with netcat
+bun plugin/scripts/worker-service.cjs hook claude-code context
+# Verify: completes gracefully, doesn't hang
+kill %1  # Clean up netcat
+```
+
+**Test 4: Full Session**
+```bash
+# Start fresh Claude Code session
+# Do some work (creates observations)
+# End session (Ctrl+C or /exit)
+# Verify: summarize hook ran, observations saved
+```
+
+---
+
+## Risk Assessment
+
+| Risk | Mitigation |
+|------|------------|
+| Hook stays alive forever | Expected - it's the worker now |
+| Multiple hooks compete for port | First one wins, others use HTTP |
+| Graceful shutdown on session end | Stop command in chain handles this |
+| Windows compatibility | No spawn = no Windows issues |
+
+## Rollback Plan
+
+If issues arise:
+1. Restore hooks.json with separate start commands
+2. Revert worker-service.ts hook case changes
+3. No database changes to rollback
@@ -0,0 +1,196 @@
+# Plan: Integrate Workflow Agents and Commands into Claude-Mem
+
+## Executive Summary
+
+This plan integrates the `/make-plan` and `/do` orchestration workflow from `~/.claude/commands/` into the claude-mem plugin as project-level development tools.
+
+## Dependency Analysis
+
+### Commands to Copy (from `~/.claude/commands/`)
+
+| File | Purpose | Dependencies |
+|------|---------|--------------|
+| `make-plan.md` | Orchestrator for LLM-friendly phased planning | Uses Task tool with subagents |
+| `do.md` | Orchestrator for executing plans via subagents | Uses Task tool with subagents |
+| `anti-pattern-czar.md` | Error handling anti-pattern detection/fixing | Uses Read, Edit, Bash tools |
+
+### Specialized Agents Referenced
+
+The `/make-plan` and `/do` commands reference these **conceptual agent roles** (not actual agent files):
+
+| Agent Role | Referenced In | Description |
+|------------|---------------|-------------|
+| "Documentation Discovery" | make-plan.md | Fact-gathering from docs/examples |
+| "Verification" | make-plan.md, do.md | Verify implementation matches plan |
+| "Implementation" | do.md | Execute implementation tasks |
+| "Anti-pattern" | do.md | Grep for known bad patterns |
+| "Code Quality" | do.md | Review code changes |
+| "Commit" | do.md | Commit after verification passes |
+| "Branch/Sync" | do.md | Push and prepare phase handoffs |
+
+**Key Finding**: These are **role descriptions**, not separate agent files. The Task tool's `general-purpose` subagent_type executes all roles. The commands define *what* each role should do, not separate agent implementations.
+
+### Existing Project Assets
+
+Located in `.claude/`:
+- `agents/github-morning-reporter.md` - Already in project
+- `skills/version-bump/SKILL.md` - Already in project
+- No existing commands directory
+
+---
+
+## Phase 0: Documentation Discovery (Complete)
+
+### Sources Consulted
+1. `/Users/alexnewman/.claude/commands/make-plan.md` (62 lines)
+2. `/Users/alexnewman/.claude/commands/do.md` (39 lines)
+3. `/Users/alexnewman/.claude/commands/anti-pattern-czar.md` (122 lines)
+4. `/Users/alexnewman/.claude/settings.json` (36 lines)
+5. `.claude/skills/CLAUDE.md` (30 lines)
+6. `.claude/agents/github-morning-reporter.md` (102 lines)
+
+### Allowed APIs/Patterns
+- **Commands**: `.claude/commands/*.md` files with `#$ARGUMENTS` placeholder for user input
+- **Skills**: `.claude/skills/<name>/SKILL.md` with YAML frontmatter (name, description)
+- **Agents**: `.claude/agents/*.md` with YAML frontmatter (name, description, model)
+
+### Anti-Patterns to Avoid
+- Skills require YAML frontmatter; commands do not
+- Commands use `#$ARGUMENTS` for input; skills/agents receive prompts differently
+- Don't create separate agent files for role descriptions - the Task tool handles routing
+
+---
+
+## Phase 1: Create Commands Directory
+
+### What to Implement
+1. Create `.claude/commands/` directory
+2. Copy `make-plan.md` from `~/.claude/commands/make-plan.md`
+3. Copy `do.md` from `~/.claude/commands/do.md`
+4. Copy `anti-pattern-czar.md` from `~/.claude/commands/anti-pattern-czar.md`
+
+### Documentation References
+- Pattern: `~/.claude/commands/*.md` (source files)
+- Existing example: `.claude/skills/version-bump/SKILL.md` for claude-mem project tools
+
+### Verification Checklist
+```bash
+# Verify files exist
+ls -la .claude/commands/
+
+# Verify content matches source
+diff ~/.claude/commands/make-plan.md .claude/commands/make-plan.md
+diff ~/.claude/commands/do.md .claude/commands/do.md
+diff ~/.claude/commands/anti-pattern-czar.md .claude/commands/anti-pattern-czar.md
+
+# Verify #$ARGUMENTS placeholder exists
+grep '\$ARGUMENTS' .claude/commands/*.md
+```
+
+### Anti-Pattern Guards
+- Do NOT add YAML frontmatter to commands (they don't need it)
+- Do NOT modify the source content (copy verbatim)
+
+---
+
+## Phase 2: Create CLAUDE.md Documentation
+
+### What to Implement
+Create `.claude/commands/CLAUDE.md` documenting the commands directory (following pattern from `.claude/skills/CLAUDE.md`)
+
+### Content Template
+```markdown
+# Project-Level Commands
+
+This directory contains slash commands **for developing and maintaining the claude-mem project itself**.
+
+## Commands in This Directory
+
+### /make-plan
+Orchestrator for creating LLM-friendly implementation plans in phases. Deploys subagents for documentation discovery and fact gathering.
+
+**Usage**: `/make-plan <task description>`
+
+### /do
+Orchestrator for executing plans via subagents. Deploys specialized subagents for implementation, verification, and code quality review.
+
+**Usage**: `/do <plan-file-path or inline plan>`
+
+### /anti-pattern-czar
+Interactive workflow for detecting and fixing error handling anti-patterns using the automated scanner.
+
+**Usage**: `/anti-pattern-czar`
+
+## Adding New Commands
+
+Commands are markdown files with `#$ARGUMENTS` placeholder for user input.
+```
+
+### Verification Checklist
+```bash
+# Verify file exists
+cat .claude/commands/CLAUDE.md
+```
+
+---
+
+## Phase 3: Update Settings (if needed)
+
+### What to Implement
+Check if `.claude/settings.json` needs any permission updates for the new commands.
+
+### Verification Checklist
+```bash
+# Check current settings
+cat .claude/settings.json
+
+# Verify commands work by listing them
+# (After Claude Code restart, commands should appear in slash-command list)
+```
+
+### Anti-Pattern Guards
+- Do NOT add skill permissions for commands (they're different)
+- Commands don't require explicit permissions
+
+---
+
+## Phase 4: Final Verification
+
+### Verification Checklist
+1. All three command files exist in `.claude/commands/`
+2. Content matches source files exactly (byte-for-byte if possible)
+3. CLAUDE.md documentation exists
+4. Git status shows new files ready for commit
+
+```bash
+# Full verification
+ls -la .claude/commands/
+wc -l .claude/commands/*.md
+git status
+```
+
+### Commit Message Template
+```
+feat: add /make-plan, /do, and /anti-pattern-czar workflow commands
+
+Add project-level orchestration commands for claude-mem development:
+- /make-plan: Create LLM-friendly implementation plans in phases
+- /do: Execute plans via coordinated subagents
+- /anti-pattern-czar: Detect and fix error handling anti-patterns
+
+These commands enable structured, agent-driven development workflows.
+```
+
+---
+
+## Summary
+
+**Files to Create**:
+1. `.claude/commands/make-plan.md` (copy from ~/.claude/commands/)
+2. `.claude/commands/do.md` (copy from ~/.claude/commands/)
+3. `.claude/commands/anti-pattern-czar.md` (copy from ~/.claude/commands/)
+4. `.claude/commands/CLAUDE.md` (new documentation)
+
+**No Agent Files Needed**: The "agents" referenced in make-plan.md and do.md are role descriptions, not separate files. The Task tool's built-in subagent types handle execution.
+
+**Confidence**: High - analysis complete with full source file reads.
@@ -0,0 +1,290 @@
+# Test Quality Audit Report
+
+**Date**: 2026-01-05
+**Auditor**: Claude Code (Opus 4.5)
+**Methodology**: Deep analysis with focus on anti-pattern prevention, actual functionality testing, and regression prevention
+
+---
+
+## Executive Summary
+
+**Total Test Files Audited**: 41
+**Total Test Cases**: ~450+
+
+### Score Distribution
+
+| Score | Category | Count | Percentage |
+|-------|----------|-------|------------|
+| 5 | Essential | 8 | 19.5% |
+| 4 | Valuable | 15 | 36.6% |
+| 3 | Marginal | 11 | 26.8% |
+| 2 | Weak | 5 | 12.2% |
+| 1 | Delete | 2 | 4.9% |
+
+### Key Findings
+
+**Strengths**:
+- SQLite database tests are exemplary - real database operations with proper setup/teardown
+- Infrastructure tests (WMIC parsing, token calculator) use pure unit testing with no mocks
+- Search strategy tests have comprehensive coverage of edge cases
+- Logger formatTool tests are thorough and test actual transformation logic
+
+**Critical Issues**:
+- **context-builder.test.ts** has incomplete mocks that pollute the module cache, causing 81 test failures when run with the full suite
+- Several tests verify mock behavior rather than actual functionality
+- Type validation tests (export-types.test.ts) provide minimal value - TypeScript already validates types at compile time
+- Some "validation" tests only verify code patterns exist, not that they work
+
+**Recommendations**:
+1. Fix or delete context-builder.test.ts - it actively harms the test suite
+2. Delete trivial type validation tests that duplicate TypeScript compiler checks
+3. Convert heavy-mock tests to integration tests where feasible
+4. Add integration tests for critical paths (hook execution, worker API endpoints)
+
+---
+
+## Detailed Scores
+
+### Score 5 - Essential (8 tests)
+
+These tests catch real bugs, use minimal mocking, and test actual behavior.
+
+| File | Test Count | Notes |
+|------|------------|-------|
+| `tests/sqlite/observations.test.ts` | 25+ | Real SQLite operations, in-memory DB, tests actual data persistence and retrieval |
+| `tests/sqlite/sessions.test.ts` | 20+ | Real database CRUD operations, status transitions, relationship integrity |
+| `tests/sqlite/transactions.test.ts` | 15+ | Critical transaction isolation tests, rollback behavior, error handling |
+| `tests/context/token-calculator.test.ts` | 35+ | Pure unit tests, no mocks, tests actual token estimation algorithms |
+| `tests/infrastructure/wmic-parsing.test.ts` | 20+ | Pure parsing logic tests, validates Windows process enumeration edge cases |
+| `tests/utils/logger-format-tool.test.ts` | 56 | Comprehensive formatTool tests, validates JSON parsing, tool output formatting |
+| `tests/server/server.test.ts` | 15+ | Real HTTP server integration tests, actual endpoint validation |
+| `tests/cursor-hook-outputs.test.ts` | 12+ | Integration tests running actual hook scripts, validates real output |
+
+**Why Essential**: These tests catch actual bugs before production. They test real behavior with minimal abstraction. The SQLite tests in particular are exemplary - they use an in-memory database but perform real SQL operations.
+
+---
+
+### Score 4 - Valuable (15 tests)
+
+Good tests with acceptable mocking that still verify meaningful behavior.
+
+| File | Test Count | Notes |
+|------|------------|-------|
+| `tests/sqlite/prompts.test.ts` | 15+ | Real DB operations for user prompts, timestamp handling |
+| `tests/sqlite/summaries.test.ts` | 15+ | Real DB operations for session summaries |
+| `tests/worker/search/search-orchestrator.test.ts` | 30+ | Comprehensive strategy selection logic, good edge case coverage |
+| `tests/worker/search/strategies/sqlite-search-strategy.test.ts` | 25+ | Filter logic tests, date range handling |
+| `tests/worker/search/strategies/hybrid-search-strategy.test.ts` | 20+ | Ranking preservation, merge logic |
+| `tests/worker/search/strategies/chroma-search-strategy.test.ts` | 20+ | Vector search behavior, doc_type filtering |
+| `tests/worker/search/result-formatter.test.ts` | 15+ | Output formatting validation |
+| `tests/gemini_agent.test.ts` | 20+ | Multi-turn conversation flow, rate limiting fallback |
+| `tests/infrastructure/health-monitor.test.ts` | 15+ | Health check logic, threshold validation |
+| `tests/infrastructure/graceful-shutdown.test.ts` | 15+ | Shutdown sequence, timeout handling |
+| `tests/infrastructure/process-manager.test.ts` | 12+ | Process lifecycle management |
+| `tests/cursor-mcp-config.test.ts` | 10+ | MCP configuration generation validation |
+| `tests/cursor-hooks-json-utils.test.ts` | 8+ | JSON parsing utilities |
+| `tests/shared/settings-defaults-manager.test.ts` | 27 | Settings validation, migration logic |
+| `tests/context/formatters/markdown-formatter.test.ts` | 15+ | Markdown generation, terminology consistency |
+
+**Why Valuable**: These tests have some mocking but still verify important business logic. The search strategy tests are particularly good at testing the decision-making logic for query routing.
+
+---
+
+### Score 3 - Marginal (11 tests)
+
+Tests with moderate value, often too much mocking or testing obvious behavior.
+
+| File | Test Count | Issues |
+|------|------------|--------|
+| `tests/worker/agents/observation-broadcaster.test.ts` | 15+ | Heavy mocking of SSE workers, tests mock behavior more than actual broadcasting |
+| `tests/worker/agents/fallback-error-handler.test.ts` | 10+ | Error message formatting tests, low complexity |
+| `tests/worker/agents/session-cleanup-helper.test.ts` | 10+ | Cleanup logic with mocked dependencies |
+| `tests/context/observation-compiler.test.ts` | 20+ | Mock database, tests query building not actual compilation |
+| `tests/server/error-handler.test.ts` | 8+ | Mock Express response, tests formatting only |
+| `tests/cursor-registry.test.ts` | 8+ | Registry pattern tests, low risk area |
+| `tests/cursor-context-update.test.ts` | 5+ | File format validation, could be stricter |
+| `tests/hook-constants.test.ts` | 5+ | Constant validation, low value |
+| `tests/session_store.test.ts` | 10+ | In-memory store tests, straightforward logic |
+| `tests/logger-coverage.test.ts` | 8+ | Coverage verification, not functionality |
+| `tests/scripts/smart-install.test.ts` | 25+ | Path array tests, replicates rather than imports logic |
+
+**Why Marginal**: These tests provide some regression protection but either mock too heavily or test low-risk areas. The smart-install tests notably replicate the path arrays from the source file rather than testing the actual module.
+
+---
+
+### Score 2 - Weak (5 tests)
+
+Tests that mostly verify mocks work or provide little value.
+
+| File | Test Count | Issues |
+|------|------------|--------|
+| `tests/worker/agents/response-processor.test.ts` | 20+ | **Heavy mocking**: >50% setup is mock configuration. Tests verify mocks are called, not that XML parsing actually works |
+| `tests/session_id_refactor.test.ts` | 10+ | **Code pattern validation**: Tests that certain patterns exist in code, not that they work |
+| `tests/session_id_usage_validation.test.ts` | 5+ | **Static analysis as tests**: Reads files and checks for string patterns. Should be a lint rule, not a test |
+| `tests/validate_sql_update.test.ts` | 5+ | **One-time validation**: Validated a migration, no ongoing value |
+| `tests/worker-spawn.test.ts` | 5+ | **Trivial mocking**: Tests spawn config exists, doesn't test actual spawning |
+
+**Why Weak**: These tests create false confidence. The response-processor tests in particular set up elaborate mocks and then verify those mocks were called - they don't verify actual XML parsing or database operations work correctly.
+
+---
+
+### Score 1 - Delete (2 tests)
+
+Tests that actively harm the codebase or provide zero value.
+
+| File | Test Count | Issues |
+|------|------------|--------|
+| `tests/context/context-builder.test.ts` | 20+ | **CRITICAL**: Incomplete logger mock pollutes module cache. Causes 81 test failures when run with full suite. Tests verify mocks, not actual context building |
+| `tests/scripts/export-types.test.ts` | 30+ | **Zero runtime value**: Tests TypeScript type definitions compile. TypeScript compiler already does this. These tests can literally never fail at runtime |
+
+**Why Delete**:
+- **context-builder.test.ts**: This test is actively harmful. It imports the logger module with an incomplete mock (only 4 of 13+ methods mocked), and this polluted mock persists in Bun's module cache. When other tests run afterwards, they get the broken logger singleton. The test itself only verifies that mocked methods were called with expected arguments - it doesn't test actual context building logic.
+- **export-types.test.ts**: These tests instantiate TypeScript interfaces and verify properties exist. TypeScript already validates this at compile time. If a type definition is wrong, the code won't compile. These runtime tests add overhead without catching any bugs that TypeScript wouldn't already catch.
+
+---
+
+## Missing Test Coverage
+
+### Critical Gaps
+
+| Area | Risk | Current Coverage | Recommendation |
+|------|------|------------------|----------------|
+| **Hook execution E2E** | HIGH | None | Add integration tests that run hooks with real Claude Code SDK |
+| **Worker API endpoints** | HIGH | Partial (server.test.ts) | Add tests for all REST endpoints: `/observe`, `/search`, `/health` |
+| **Chroma vector sync** | HIGH | None | Add tests for ChromaSync.ts embedding generation and retrieval |
+| **Database migrations** | MEDIUM | None | Add tests for schema migrations, especially version upgrades |
+| **Settings file I/O** | MEDIUM | Partial | Add tests for settings file creation, corruption recovery |
+| **Tag stripping** | MEDIUM | None | Add tests for `<private>` and `<meta-observation>` tag handling |
+| **MCP tool handlers** | MEDIUM | None | Add tests for search, timeline, get_observations MCP tools |
+| **Error recovery** | MEDIUM | Minimal | Add tests for worker crash recovery, database corruption handling |
+
+### Recommended New Tests
+
+1. **`tests/integration/hook-execution.test.ts`**
+   - Run actual hooks with mocked Claude Code environment
+   - Verify data flows correctly through SessionStart -> PostToolUse -> SessionEnd
+
+2. **`tests/integration/worker-api.test.ts`**
+   - Start actual worker server
+   - Make real HTTP requests to all endpoints
+   - Verify response formats and error handling
+
+3. **`tests/services/chroma-sync.test.ts`**
+   - Test embedding generation with real text
+   - Test semantic similarity retrieval
+   - Test sync between SQLite and Chroma
+
+4. **`tests/utils/tag-stripping.test.ts`**
+   - Test `<private>` tag removal
+   - Test `<meta-observation>` tag handling
+   - Test nested tag scenarios
+
+---
+
+## Recommendations
+
+### Immediate Actions
+
+1. **Delete or fix `tests/context/context-builder.test.ts`** (Priority: CRITICAL)
+   - This test causes 81 other tests to fail due to module cache pollution
+   - Either complete the logger mock (all 13+ methods) or delete entirely
+   - Recommended: Delete and rewrite as integration test without mocks
+
+2. **Delete `tests/scripts/export-types.test.ts`** (Priority: HIGH)
+   - Zero runtime value - TypeScript compiler already validates types
+   - Remove to reduce test suite noise
+
+3. **Delete or convert validation tests** (Priority: MEDIUM)
+   - `tests/session_id_refactor.test.ts` - Was useful during migration, no longer needed
+   - `tests/session_id_usage_validation.test.ts` - Convert to lint rule
+   - `tests/validate_sql_update.test.ts` - Was useful during migration, no longer needed
+
+### Architecture Improvements
+
+1. **Create test utilities for common mocks**
+   - Centralize logger mock in `tests/utils/mock-logger.ts` with ALL methods
+   - Centralize database mock with proper transaction support
+   - Prevent incomplete mocks from polluting module cache
+
+2. **Add integration test suite**
+   - Create `tests/integration/` directory
+   - Run with real worker server (separate database)
+   - Test actual data flow, not mock interactions
+
+3. **Implement test isolation**
+   - Use `beforeEach` to reset module state
+   - Consider test file ordering to prevent cache pollution
+   - Add cleanup hooks for database state
+
+### Quality Guidelines
+
+For future tests, follow these principles:
+
+1. **Prefer real implementations over mocks**
+   - Use in-memory SQLite instead of mock database
+   - Use real HTTP requests instead of mock req/res
+   - Mock only external services (AI APIs, file system when needed)
+
+2. **Test behavior, not implementation**
+   - Bad: "verify function X was called with argument Y"
+   - Good: "verify output contains expected data after operation"
+
+3. **Each test should be able to fail**
+   - If a test cannot fail (like type validation tests), it's not testing anything
+   - Write tests that would catch real bugs
+
+4. **Keep test setup minimal**
+   - If >50% of test is mock setup, consider integration testing
+   - Complex mock setup often indicates testing the wrong thing
+
+---
+
+## Appendix: Full Test File Inventory
+
+| File | Score | Tests | LOC | Mock % |
+|------|-------|-------|-----|--------|
+| `tests/context/context-builder.test.ts` | 1 | 20+ | 400+ | 80% |
+| `tests/context/formatters/markdown-formatter.test.ts` | 4 | 15+ | 200+ | 10% |
+| `tests/context/observation-compiler.test.ts` | 3 | 20+ | 300+ | 60% |
+| `tests/context/token-calculator.test.ts` | 5 | 35+ | 400+ | 0% |
+| `tests/cursor-context-update.test.ts` | 3 | 5+ | 100+ | 20% |
+| `tests/cursor-hook-outputs.test.ts` | 5 | 12+ | 250+ | 10% |
+| `tests/cursor-hooks-json-utils.test.ts` | 4 | 8+ | 150+ | 0% |
+| `tests/cursor-mcp-config.test.ts` | 4 | 10+ | 200+ | 20% |
+| `tests/cursor-registry.test.ts` | 3 | 8+ | 150+ | 30% |
+| `tests/gemini_agent.test.ts` | 4 | 20+ | 400+ | 40% |
+| `tests/hook-constants.test.ts` | 3 | 5+ | 80+ | 0% |
+| `tests/infrastructure/graceful-shutdown.test.ts` | 4 | 15+ | 300+ | 40% |
+| `tests/infrastructure/health-monitor.test.ts` | 4 | 15+ | 250+ | 30% |
+| `tests/infrastructure/process-manager.test.ts` | 4 | 12+ | 200+ | 35% |
+| `tests/infrastructure/wmic-parsing.test.ts` | 5 | 20+ | 240+ | 0% |
+| `tests/logger-coverage.test.ts` | 3 | 8+ | 150+ | 20% |
+| `tests/scripts/export-types.test.ts` | 1 | 30+ | 350+ | 0% |
+| `tests/scripts/smart-install.test.ts` | 3 | 25+ | 230+ | 0% |
+| `tests/server/error-handler.test.ts` | 3 | 8+ | 150+ | 50% |
+| `tests/server/server.test.ts` | 5 | 15+ | 300+ | 20% |
+| `tests/session_id_refactor.test.ts` | 2 | 10+ | 200+ | N/A |
+| `tests/session_id_usage_validation.test.ts` | 2 | 5+ | 150+ | N/A |
+| `tests/session_store.test.ts` | 3 | 10+ | 180+ | 10% |
+| `tests/shared/settings-defaults-manager.test.ts` | 4 | 27 | 400+ | 20% |
+| `tests/sqlite/observations.test.ts` | 5 | 25+ | 400+ | 0% |
+| `tests/sqlite/prompts.test.ts` | 4 | 15+ | 250+ | 0% |
+| `tests/sqlite/sessions.test.ts` | 5 | 20+ | 350+ | 0% |
+| `tests/sqlite/summaries.test.ts` | 4 | 15+ | 250+ | 0% |
+| `tests/sqlite/transactions.test.ts` | 5 | 15+ | 300+ | 0% |
+| `tests/utils/logger-format-tool.test.ts` | 5 | 56 | 1000+ | 0% |
+| `tests/validate_sql_update.test.ts` | 2 | 5+ | 100+ | N/A |
+| `tests/worker/agents/fallback-error-handler.test.ts` | 3 | 10+ | 200+ | 40% |
+| `tests/worker/agents/observation-broadcaster.test.ts` | 3 | 15+ | 350+ | 60% |
+| `tests/worker/agents/response-processor.test.ts` | 2 | 20+ | 500+ | 70% |
+| `tests/worker/agents/session-cleanup-helper.test.ts` | 3 | 10+ | 200+ | 50% |
+| `tests/worker/search/result-formatter.test.ts` | 4 | 15+ | 250+ | 20% |
+| `tests/worker/search/search-orchestrator.test.ts` | 4 | 30+ | 500+ | 45% |
+| `tests/worker/search/strategies/chroma-search-strategy.test.ts` | 4 | 20+ | 350+ | 50% |
+| `tests/worker/search/strategies/hybrid-search-strategy.test.ts` | 4 | 20+ | 300+ | 45% |
+| `tests/worker/search/strategies/sqlite-search-strategy.test.ts` | 4 | 25+ | 350+ | 40% |
+| `tests/worker-spawn.test.ts` | 2 | 5+ | 100+ | 60% |
+
+---
+
+*Report generated by Claude Code (Opus 4.5) on 2026-01-05*
@@ -26,4 +26,4 @@ Manages semantic versioning for the claude-mem project itself. Handles updating
 ## Adding New Skills

 **For claude-mem development** → Add to `.claude/skills/`
-**For end users** → Add to `plugin/skills/` (gets distributed with plugin)
+**For end users** → Add to `plugin/skills/` (gets distributed with plugin)
@@ -1,80 +0,0 @@
---
-name: version-bump
-description: Manage semantic version updates for claude-mem project. Handles patch, minor, and major version increments following semantic versioning. Updates package.json, marketplace.json, and plugin.json. Creates git tags and GitHub releases. Auto-generates CHANGELOG.md from releases.
---
-
-# Version Bump Skill
-
-**IMPORTANT:** You must first ultrathink and write detailed release notes before starting the version bump workflow.
-
-## Version Types
-
- **PATCH** (x.y.Z): Bug fixes only
- **MINOR** (x.Y.0): New features, backward compatible
- **MAJOR** (X.0.0): Breaking changes
-
-## Files to Update (ALL THREE)
-
-1. `package.json` (line 3)
-2. `.claude-plugin/marketplace.json` (line 13)
-3. `plugin/.claude-plugin/plugin.json` (line 3)
-
-## Workflow
-
-```bash
-# 1. Check current version
-grep '"version"' package.json .claude-plugin/marketplace.json plugin/.claude-plugin/plugin.json
-
-# 2. Update all 3 files to new version (use Edit tool)
-
-# 3. Verify consistency
-grep '"version"' package.json .claude-plugin/marketplace.json plugin/.claude-plugin/plugin.json
-
-# 4. Build
-npm run build
-
-# 5. Commit version files
-git add package.json .claude-plugin/marketplace.json plugin/.claude-plugin/plugin.json
-git commit -m "chore: bump version to X.Y.Z"
-
-# 6. Create tag
-git tag -a vX.Y.Z -m "Version X.Y.Z"
-
-# 7. Push
-git push origin main && git push origin vX.Y.Z
-
-# 8. Create GitHub release (use your detailed release notes here)
-gh release create vX.Y.Z --title "vX.Y.Z" --notes "RELEASE_NOTES_HERE"
-
-# 9. Generate CHANGELOG.md from releases
-gh api repos/thedotmack/claude-mem/releases --paginate | node -e "
-const releases = JSON.parse(require('fs').readFileSync(0, 'utf8'));
-const lines = ['# Changelog', '', 'All notable changes to claude-mem.', ''];
-releases.slice(0, 50).forEach(r => {
-  const date = r.published_at.split('T')[0];
-  lines.push('## [' + r.tag_name + '] - ' + date);
-  lines.push('');
-  if (r.body) lines.push(r.body.trim());
-  lines.push('');
-});
-console.log(lines.join('\n'));
-" > CHANGELOG.md
-
-# 10. Commit CHANGELOG
-git add CHANGELOG.md
-git commit -m "docs: update CHANGELOG.md for vX.Y.Z"
-git push origin main
-
-# 11. Discord notification
-npm run discord:notify vX.Y.Z
-```
-
-## Checklist
-
- [ ] Ultrathink + write detailed release notes
- [ ] All 3 files have matching version
- [ ] `npm run build` succeeds
- [ ] Git tag created (vX.Y.Z format)
- [ ] GitHub release created with detailed notes
- [ ] CHANGELOG.md updated
- [ ] Discord notification sent (if webhook configured)
@@ -7,6 +7,12 @@ assignees: ''

 ---

+## Before submitting
+
+- [ ] I searched [existing issues](https://github.com/thedotmack/claude-mem/issues) and confirmed this is not a duplicate
+
+---
+
 ## ⚡ Quick Bug Report (Recommended)

 **Use the automated bug report generator** for comprehensive diagnostics:
@@ -7,6 +7,12 @@ assignees: ''

 ---

+## Before submitting
+
+- [ ] I searched [existing issues](https://github.com/thedotmack/claude-mem/issues) and confirmed this is not a duplicate
+
+---
+
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

@@ -9,16 +9,29 @@ dist/
 *.temp
 .install-version
 .claude/settings.local.json
+.claude/agents/
+.claude/skills/
 plugin/data/
 plugin/data.backup/
 package-lock.json
 bun.lock
 private/
 datasets/
+Auto Run Docs/

 # Generated UI files (built from viewer-template.html)
 src/ui/viewer.html

 # Local MCP server config (for development only)
 .mcp.json
-.cursor/
+.cursor/
+
+# Prevent literal tilde directories (path validation bug artifacts)
+~*/
+
+# Prevent other malformed path directories
+http*/
+https*/
+
+# Ignore WebStorm project files (for dinosaur IDE users)
+.idea/
@@ -19,10 +19,7 @@ Claude-mem is a Claude Code plugin providing persistent memory across sessions.
 **Viewer UI** (`src/ui/viewer/`) - React interface at http://localhost:37777, built to `plugin/ui/viewer.html`

 ## Privacy Tags
-
-**Dual-Tag System** for meta-observation control:
 - `<private>content</private>` - User-level privacy control (manual, prevents storage)
- `<claude-mem-context>content</claude-mem-context>` - System-level tag (auto-injected observations, prevents recursive storage)

 **Implementation**: Tag stripping happens at hook layer (edge processing) before data reaches worker/database. See `src/utils/tag-stripping.ts` for shared utilities.

@@ -44,6 +41,18 @@ Settings are managed in `~/.claude-mem/settings.json`. The file is auto-created
 - **Database**: `~/.claude-mem/claude-mem.db`
 - **Chroma**: `~/.claude-mem/chroma/`

+## Exit Code Strategy
+
+Claude-mem hooks use specific exit codes per Claude Code's hook contract:
+
+- **Exit 0**: Success or graceful shutdown (Windows Terminal closes tabs)
+- **Exit 1**: Non-blocking error (stderr shown to user, continues)
+- **Exit 2**: Blocking error (stderr fed to Claude for processing)
+
+**Philosophy**: Worker/hook errors exit with code 0 to prevent Windows Terminal tab accumulation. The wrapper/plugin layer handles restart logic. ERROR-level logging is maintained for diagnostics.
+
+See `private/context/claude-code/exit-codes.md` for full hook behavior matrix.
+
 ## Requirements

 - **Bun** (all platforms - auto-installed if missing)
@@ -1,306 +0,0 @@
-# Monolith Refactor Report
-
-> **Last Updated:** 2026-01-03 (post session-logging merge)
-
-## Executive Summary
-
-The claude-mem codebase contains **~21,000 lines** of TypeScript across 71+ files. Analysis reveals several monolithic files that violate single-responsibility principles and create tight coupling. This report identifies refactoring targets and proposes a modular architecture.
-
-**Recent Changes:** The `session-logging` branch merge improved error handling across the codebase. SearchManager was reduced by ~180 lines, but SessionStore grew by ~110 lines due to new migrations and logging.
-
---
-
-## Part 1: Monolith Files Identified
-
-### Critical Priority (>1500 lines)
-
-| File | Lines | Methods | Primary Issues | Trend |
-|------|-------|---------|----------------|-------|
-| `src/services/worker-service.ts` | 2,034 | - | Server init, process management, Cursor hooks, MCP setup all mixed | ↓ -28 |
-| `src/services/sqlite/SessionStore.ts` | 2,011 | 49 | Migrations + CRUD + queries + transformations all in one class | ↑ +108 |
-| `src/services/worker/SearchManager.ts` | 1,778 | 17 | Three search strategies crammed together, formatting mixed in | ↓ -178 |
-
-### High Priority (500-1500 lines)
-
-| File | Lines | Issues | Trend |
-|------|-------|--------|-------|
-| `src/services/sync/ChromaSync.ts` | 870 | Sync and query operations mixed | — |
-| `src/services/context-generator.ts` | 659 | 23 standalone functions, no class structure | — |
-| `src/services/worker/http/routes/SessionRoutes.ts` | 625 | Provider selection mixed with business logic | ↑ +7 |
-| `src/services/worker/OpenRouterAgent.ts` | 599 | 80% code duplicated from other agents | ↓ -15 |
-| `src/services/worker/GeminiAgent.ts` | 574 | 80% code duplicated from other agents | ↓ -15 |
-| `src/services/worker/SDKAgent.ts` | 546 | Base patterns duplicated across all agents | ↓ -15 |
-| `src/services/sqlite/SessionSearch.ts` | 526 | FTS5 tables maintained for backward compat | — |
-| `src/services/sqlite/migrations.ts` | 509 | All 11 migrations in single file | — |
-| `src/services/sqlite/PendingMessageStore.ts` | 447 | Message queue operations | ↑ +21 |
-| `src/services/worker/http/routes/SettingsRoutes.ts` | 414 | File I/O, validation, git ops mixed | — |
-
-### Code Duplication Issue
-
-The three agent files (`SDKAgent`, `GeminiAgent`, `OpenRouterAgent`) share ~80% duplicate code:
- Message building logic
- Result parsing
- Context updating
- Database sync patterns
-
---
-
-## Part 2: System Breakdown Proposal
-
-### Domain-Based Module Architecture
-
-```
-src/
-├── domains/                    # Business domain modules
-│   ├── sessions/               # Session lifecycle
-│   │   ├── SessionRepository.ts
-│   │   ├── SessionService.ts
-│   │   └── types.ts
-│   │
-│   ├── observations/           # Observation management
-│   │   ├── ObservationRepository.ts
-│   │   ├── ObservationService.ts
-│   │   └── types.ts
-│   │
-│   ├── summaries/              # Summary generation
-│   │   ├── SummaryRepository.ts
-│   │   ├── SummaryService.ts
-│   │   └── types.ts
-│   │
-│   ├── prompts/                # Prompt storage
-│   │   ├── PromptRepository.ts
-│   │   └── types.ts
-│   │
-│   └── search/                 # Search subsystem
-│       ├── strategies/
-│       │   ├── ChromaSearchStrategy.ts
-│       │   ├── FilterSearchStrategy.ts
-│       │   └── SearchStrategy.ts (interface)
-│       ├── SearchOrchestrator.ts
-│       ├── ResultFormatter.ts
-│       └── TimelineBuilder.ts
-│
-├── infrastructure/             # Cross-cutting infrastructure
-│   ├── database/
-│   │   ├── DatabaseConnection.ts
-│   │   ├── TransactionManager.ts
-│   │   └── migrations/
-│   │       ├── MigrationRunner.ts
-│   │       ├── 001_initial.ts
-│   │       ├── 002_add_prompts.ts
-│   │       └── ...
-│   │
-│   ├── vector/
-│   │   ├── ChromaClient.ts
-│   │   ├── ChromaSyncManager.ts
-│   │   └── ChromaQueryEngine.ts
-│   │
-│   └── agents/
-│       ├── BaseAgent.ts        # Shared agent logic
-│       ├── AgentFactory.ts
-│       ├── MessageBuilder.ts
-│       ├── ResponseParser.ts
-│       ├── providers/
-│       │   ├── ClaudeProvider.ts
-│       │   ├── GeminiProvider.ts
-│       │   └── OpenRouterProvider.ts
-│       └── types.ts
-│
-├── api/                        # HTTP layer
-│   ├── routes/
-│   │   ├── sessions.ts
-│   │   ├── data.ts
-│   │   ├── search.ts
-│   │   ├── settings.ts
-│   │   └── viewer.ts
-│   ├── middleware/
-│   └── server.ts
-│
-├── context/                    # Context injection
-│   ├── ContextBuilder.ts
-│   ├── ContextConfigLoader.ts
-│   ├── ObservationCompiler.ts
-│   └── TokenCalculator.ts
-│
-└── shared/                     # Shared utilities (existing)
-    ├── logger.ts
-    ├── settings.ts
-    └── ...
-```
-
---
-
-## Part 3: Refactoring Targets by Priority
-
-### Phase 1: Database Layer Decomposition
-
-**Target:** `src/services/sqlite/SessionStore.ts` (2,011 lines, 49 methods → ~5 files)
-
-| Extract To | Responsibility | Est. Lines |
-|------------|---------------|------------|
-| `domains/sessions/SessionRepository.ts` | Session CRUD ops | ~300 |
-| `domains/observations/ObservationRepository.ts` | Observation storage/retrieval | ~400 |
-| `domains/summaries/SummaryRepository.ts` | Summary storage/retrieval | ~200 |
-| `infrastructure/database/migrations/MigrationRunner.ts` | Schema migrations | ~250 |
-
-**Benefits:**
- Single responsibility per file
- Testable in isolation
- Reduces coupling
-
---
-
-### Phase 2: Agent Consolidation
-
-**Target:** 3 agent files (1,719 lines → ~800 lines total)
-
-| Extract To | Responsibility |
-|------------|---------------|
-| `infrastructure/agents/BaseAgent.ts` | Common agent logic, prompt building |
-| `infrastructure/agents/MessageBuilder.ts` | Message construction |
-| `infrastructure/agents/ResponseParser.ts` | Result parsing (observations, summaries) |
-| `infrastructure/agents/providers/*.ts` | Provider-specific API calls only |
-
-**Benefits:**
- Eliminates 80% code duplication
- Easy to add new providers
- Centralized message format changes
-
---
-
-### Phase 3: Search Strategy Pattern
-
-**Target:** `src/services/worker/SearchManager.ts` (1,778 lines → ~5 files)
-
-| Extract To | Responsibility |
-|------------|---------------|
-| `domains/search/SearchOrchestrator.ts` | Coordinates search strategies |
-| `domains/search/strategies/ChromaSearchStrategy.ts` | Vector search via Chroma |
-| `domains/search/strategies/FilterSearchStrategy.ts` | SQLite filter-based search |
-| `domains/search/ResultFormatter.ts` | Formats search results |
-| `domains/search/TimelineBuilder.ts` | Constructs timeline views |
-
-**Benefits:**
- Strategy pattern for extensibility
- Clear fallback logic
- Testable strategies
-
---
-
-### Phase 4: Context Generator Restructure
-
-**Target:** `src/services/context-generator.ts` (659 lines → ~4 files)
-
-| Extract To | Responsibility |
-|------------|---------------|
-| `context/ContextBuilder.ts` | Main builder class |
-| `context/ContextConfigLoader.ts` | Config loading/validation |
-| `context/ObservationCompiler.ts` | Compiles observations for injection |
-| `context/TokenCalculator.ts` | Token budget calculations |
-
-**Benefits:**
- Class-based structure
- Clear dependencies
- Easier testing
-
---
-
-### Phase 5: Server/Infrastructure Split
-
-**Target:** `src/services/worker-service.ts` (2,034 lines → ~4 files)
-
-| Extract To | Responsibility |
-|------------|---------------|
-| `api/server.ts` | Express app, route registration |
-| `infrastructure/ProcessManager.ts` | PID files, signal handlers |
-| `infrastructure/CursorHooksInstaller.ts` | Cursor integration |
-| `infrastructure/MCPClientManager.ts` | MCP client lifecycle |
-
---
-
-## Part 4: Dependency Reduction Strategy
-
-### Current Pain Points
-
-1. **SessionStore** imported by 7+ files directly
-2. No abstraction between routes and data access
-3. All routes depend on `DatabaseManager` which exposes raw `SessionStore`
-
-### Proposed Dependency Injection
-
-```typescript
-// infrastructure/container.ts
-export interface ServiceContainer {
-  sessions: SessionService;
-  observations: ObservationService;
-  summaries: SummaryService;
-  search: SearchOrchestrator;
-  agents: AgentFactory;
-}
-
-// Usage in routes
-app.post('/sessions', (req, res) => {
-  const { sessions } = getContainer();
-  sessions.create(req.body);
-});
-```
-
---
-
-## Part 5: Migration Strategy
-
-### Incremental Approach
-
-Each phase can be done independently without breaking the system:
-
-1. **Create new modules** alongside existing code
-2. **Migrate routes one at a time** to use new modules
-3. **Deprecate old code** once all routes migrated
-4. **Remove deprecated code** after testing
-
-### Testing Requirements
-
- Unit tests for each extracted module
- Integration tests for repository operations
- End-to-end tests for API routes
-
---
-
-## Appendix: File Size Distribution
-
-```
-2,034  src/services/worker-service.ts          ████████████████████
-2,011  src/services/sqlite/SessionStore.ts     ████████████████████
-1,778  src/services/worker/SearchManager.ts    █████████████████
-  870  src/services/sync/ChromaSync.ts         ████████
-  659  src/services/context-generator.ts       ██████
-  625  src/services/worker/http/routes/SessionRoutes.ts  ██████
-  599  src/services/worker/OpenRouterAgent.ts  █████
-  574  src/services/worker/GeminiAgent.ts      █████
-  546  src/services/worker/SDKAgent.ts         █████
-  526  src/services/sqlite/SessionSearch.ts    █████
-  509  src/services/sqlite/migrations.ts       █████
-  466  src/services/worker/http/routes/DataRoutes.ts     ████
-  447  src/services/sqlite/PendingMessageStore.ts        ████
-  414  src/services/worker/http/routes/SettingsRoutes.ts ████
-```
-
---
-
-## Summary
-
-| Metric | Current | After Refactor |
-|--------|---------|----------------|
-| Files >500 lines | 14 | 0-2 |
-| Max file size | 2,034 | ~400 |
-| Code duplication | ~1,100 lines | ~100 lines |
-| Testable modules | Low | High |
-
-**Recommended Start:** Phase 1 (SessionStore decomposition) - highest impact, clearest boundaries, and **growing** (now 2,011 lines with 49 methods).
-
-### Key Observations Post-Merge
-
-1. **SessionStore is still the top priority** - it grew by 108 lines and is now the 2nd largest file
-2. **SearchManager improved** - down 178 lines from error handling refactor
-3. **Agent files slightly smaller** - ~45 lines combined reduction
-4. **Core architecture unchanged** - the proposed modular structure remains valid
@@ -1,106 +0,0 @@
-# Queue System Simplification Plan
-
-## 1. Executive Summary
-The current queue system suffers from accidental complexity due to **state duplication** (in-memory vs. database), **fragile control flow** (recursive restarts), and **distributed state management**. This plan proposes a refactoring to establish the Database as the Single Source of Truth, unifying the processing logic into a robust, linear "Pump" model.
-
-## 2. Identified Pain Points
-
-1.  **Dual State Synchronization:**
-    *   *Issue:* The system maintains both `session.pendingMessages` (in-memory array) and the `pending_messages` SQLite table.
-    *   *Impact:* Requires constant manual synchronization (push/shift/enqueue), leading to race conditions where the in-memory queue drifts from the DB state.
-
-2.  **Fragile Generator Lifecycle:**
-    *   *Issue:* The use of `startGeneratorWithProvider` and `startSessionWithAutoRestart` with recursive `setTimeout` calls to keep the processor alive is brittle.
-    *   *Impact:* Hard to debug, prone to stack issues or silent failures if the "chain" breaks.
-
-3.  **Non-Atomic State Transitions:**
-    *   *Issue:* The logic separates "peeking" a message from "marking it processing" (the "Critical Flow" identified in the analysis).
-    *   *Impact:* If the worker crashes or halts between these steps, messages can be processed twice or lost in limbo.
-
-4.  **Distributed Logic:**
-    *   *Issue:* Queue logic is scattered across `SessionManager` (coordination), `PendingMessageStore` (DB queries), `SDKAgent` (consumption), and `WorkerService` (orchestration).
-    *   *Impact:* Difficult to trace the lifecycle of a single message.
-
-## 3. Proposed Architecture
-
-### 3.1. Core Principle: "The Database is the Queue"
-We will eliminate the in-memory `pendingMessages` array entirely. The SQLite database will be the *only* place where queue state exists.
-
-### 3.2. Architecture Components
-
-#### A. Atomic `claimNextMessage()`
-Instead of `peek` then `mark`, we will implement a single atomic operation in `PendingMessageStore`.
-
-*   **Logic:**
-    1.  Find the oldest `pending` message for the session.
-    2.  Update it to `processing` and set the timestamp.
-    3.  Return the message record.
-*   **SQL Strategy:** Use a transaction or `UPDATE ... RETURNING` (if supported) to ensure no other worker can claim the same message.
-
-#### B. The `QueuePump` (Unified Processor)
-We will replace the recursive generator logic with a class (or function) dedicated to "pumping" messages for a specific session.
-
-*   **Pseudocode Structure:**
-    ```typescript
-    async function runSessionPump(sessionId: number, signal: AbortSignal) {
-        while (!signal.aborted) {
-            // 1. Atomic Claim
-            const message = store.claimNextMessage(sessionId);
-            
-            if (!message) {
-                // 2. Wait for signal (Event-driven, not polling)
-                await waitForNewData(sessionId, signal);
-                continue;
-            }
-
-            try {
-                // 3. Process
-                await sdkAgent.processMessage(message);
-                
-                // 4. Mark Complete
-                store.markProcessed(message.id);
-            } catch (error) {
-                // 5. Handle Failure
-                store.markFailed(message.id, error);
-            }
-        }
-    }
-    ```
-
-### 3.3. Key Changes
-
-| Component | Current State | Proposed State |
-| :--- | :--- | :--- |
-| **Storage** | In-memory Array + SQLite | SQLite Only |
-| **Consumption** | `yield` loop inside SDK Agent | `QueuePump` calls SDK Agent per message |
-| **Concurrency** | `peekPending` -> `markProcessing` (Race Prone) | `claimNextMessage` (Atomic Transaction) |
-| **Lifecycle** | Recursive `setTimeout` loops | Single `while` loop with `await` |
-| **Recovery** | `resetStuckMessages` (Global) | Pump handles own retries + Global cleanup on startup |
-
-## 4. Implementation Steps
-
-### Phase 1: Database Layer Hardening
-1.  Add `claimNextMessage(sessionDbId)` to `PendingMessageStore`.
-    *   Must be transactional.
-    *   Returns `null` if no work is available.
-2.  Ensure `markProcessed` and `markFailed` are robust.
-
-### Phase 2: The Pump
-1.  Create `SessionQueueProcessor.ts`.
-2.  Implement the `while(!aborted)` loop.
-3.  Integrate the `EventEmitter` to wake the loop when `enqueue()` happens (replacing the current polling-like behavior).
-
-### Phase 3: SDK Integration
-1.  Refactor `SDKAgent` to accept a *single* message or a streamlined iterator that doesn't manage queue state itself.
-2.  Remove `session.pendingMessages` from `ActiveSession` type.
-
-### Phase 4: Cleanup
-1.  Remove `startGeneratorWithProvider` and `startSessionWithAutoRestart`.
-2.  Remove `peekPending` (as it's replaced by `claimNextMessage`).
-3.  Remove manual synchronization code in `SessionManager`.
-
-## 5. Benefits
-*   **Simplicity:** Code reduction of ~30-40%.
-*   **Reliability:** Atomic database operations eliminate race conditions.
-*   **Observability:** Linear control flow is easier to log and debug.
-*   **Resilience:** Crashes are handled by simply restarting the Pump, which naturally picks up "processing" (stuck) or "pending" messages.
@@ -1,46 +0,0 @@
-# Queue System Simplification Implementation
-
-I have successfully implemented the queue system simplification plan.
-
-## Changes Implemented
-
-### 1. Database Layer Hardening
- **Added `claimNextMessage(sessionDbId)` to `PendingMessageStore`:**
-  - Implements an atomic transaction (SELECT oldest pending + UPDATE to processing).
-  - Ensures a message can only be claimed by one worker at a time.
-  - Eliminates race conditions between "peeking" and "marking".
- **Removed `peekPending()`:**
-  - No longer needed as `claimNextMessage` handles retrieval and locking in one step.
-
-### 2. Unified "Pump" Architecture
- **Created `src/services/queue/SessionQueueProcessor.ts`:**
-  - Implements a robust `AsyncIterableIterator` that yields messages.
-  - Encapsulates the "Claim -> Yield -> Wait" loop.
-  - Replaces fragile polling/recursive logic with event-driven `waitForMessage`.
-  - Handles empty queues gracefully by waiting for signals.
-
-### 3. SessionManager Refactoring
- **Updated `getMessageIterator`:**
-  - Now delegates to `SessionQueueProcessor`.
-  - Removes complex manual synchronization logic.
- **Removed In-Memory Queue State:**
-  - `queueObservation` and `queueSummarize` now only write to DB and emit events.
-  - `pendingMessages` array is no longer used for logic (kept deprecated for type compatibility).
-  - `getTotalActiveWork`, `hasPendingMessages`, etc., now query `PendingMessageStore` directly (counting both 'pending' and 'processing' states).
-
-### 4. Logic Cleanup
- **Removed Recursive Restarts:**
-  - Refactored `startGeneratorWithProvider` in `SessionRoutes.ts` and `startSessionProcessor` in `WorkerService.ts`.
-  - Removed logic that deleted sessions when queue emptied (sessions now wait for new work).
-  - Removed "auto-restart" logic for normal completion (only kept for crash recovery).
-
-## Benefits
- **Reliability:** Atomic DB operations prevent stuck or duplicate messages.
- **Simplicity:** Removed complex "peek-then-mark" and recursive restart chains.
- **Performance:** Zero-latency event notification with efficient DB queries.
- **Maintainability:** Clear separation of concerns (Store vs Processor vs Manager).
-
-## Verification
- Ran static analysis (`tsc`) to verify type safety of new components.
- Verified removal of dead code (`peekPending`).
- Confirmed integration points in `SessionManager` and `SessionRoutes`.
@@ -1,742 +0,0 @@
-# Queue System Logic Report
-
-This document provides a line-by-line analysis of the queue system in claude-mem, explaining **the reason behind each piece of logic** and **what it actually does**.
-
---
-
-## Table of Contents
-
-1. [High-Level Architecture](#high-level-architecture)
-2. [Message Status State Machine](#message-status-state-machine)
-3. [PendingMessageStore (Database Layer)](#pendingmessagestore-database-layer)
-4. [SessionManager (Queue Coordination)](#sessionmanager-queue-coordination)
-5. [SDKAgent (Message Consumer)](#sdkagent-message-consumer)
-6. [SessionRoutes (HTTP Entry Points)](#sessionroutes-http-entry-points)
-7. [WorkerService (Orchestrator)](#workerservice-orchestrator)
-8. [Critical Flow: How a Message Gets Stuck in "Processing"](#critical-flow-how-a-message-gets-stuck-in-processing)
-9. [Recovery Mechanisms](#recovery-mechanisms)
-
---
-
-## High-Level Architecture
-
-```
-Hook (post-tool-use/summary)
-    │
-    ▼
-SessionRoutes.handleObservations/handleSummarize
-    │
-    ▼
-SessionManager.queueObservation/queueSummarize
-    │
-    ├─► PendingMessageStore.enqueue() [DB: status='pending']
-    │
-    ├─► session.pendingMessages.push() [In-memory queue]
-    │
-    └─► emitter.emit('message') [Wake up generator]
-
-    │
-    ▼
-SDKAgent.createMessageGenerator (async generator)
-    │
-    ├─► SessionManager.getMessageIterator()
-    │       │
-    │       ├─► PendingMessageStore.peekPending() [Find oldest pending]
-    │       │
-    │       ├─► PendingMessageStore.markProcessing() [DB: status='processing']
-    │       │
-    │       └─► yield message to SDK
-    │
-    ▼
-SDK query() processes message and returns response
-    │
-    ▼
-SDKAgent.processSDKResponse()
-    │
-    └─► SDKAgent.markMessagesProcessed()
-            │
-            └─► PendingMessageStore.markProcessed() [DB: status='processed']
-```
-
---
-
-## Message Status State Machine
-
-```
-                   ┌─────────────┐
-                   │   (new)     │
-                   └──────┬──────┘
-                          │ enqueue()
-                          ▼
-                   ┌─────────────┐
-              ┌────│   pending   │◄───────────────┐
-              │    └──────┬──────┘                │
-              │           │ markProcessing()      │ markFailed() [retry_count < maxRetries]
-              │           ▼                       │
-              │    ┌─────────────┐                │
-              │    │ processing  │────────────────┤
-              │    └──────┬──────┘                │
-              │           │                       │
-              │           ├─► markProcessed()     │
-              │           │         │             │
-              │           │         ▼             │
-              │           │  ┌─────────────┐      │
-              │           │  │  processed  │      │
-              │           │  └─────────────┘      │
-              │           │                       │
-              │           └─► markFailed() [retry_count >= maxRetries]
-              │                     │
-              │                     ▼
-              │              ┌─────────────┐
-              │              │   failed    │
-              │              └─────────────┘
-              │
-              │
-              │ resetStuckMessages() [thresholdMs timeout]
-              └───────────────────────────────────┘
-```
-
---
-
-## PendingMessageStore (Database Layer)
-
-### `enqueue()` (Lines 56-82)
-
-```typescript
-enqueue(sessionDbId: number, claudeSessionId: string, message: PendingMessage): number {
-  const now = Date.now();
-  const stmt = this.db.prepare(`
-    INSERT INTO pending_messages (
-      session_db_id, claude_session_id, message_type,
-      tool_name, tool_input, tool_response, cwd,
-      last_user_message, last_assistant_message,
-      prompt_number, status, retry_count, created_at_epoch
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?)
-  `);
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `const now = Date.now()` | Messages need timestamps for ordering and stuck-detection | Captures the moment the message was queued |
-| `status, retry_count ... 'pending', 0` | New messages start in pending state with no retries | Hard-codes initial state in SQL |
-| `created_at_epoch` | Need to track when message was originally queued for accurate observation timestamps | Used later when processing backlog to assign correct timestamps to observations |
-| `JSON.stringify(message.tool_input)` | SQLite can't store objects natively | Serializes complex tool data to string |
-| Returns `lastInsertRowid` | Caller needs the ID to track this specific message | Returns the database-assigned auto-increment ID |
-
-### `peekPending()` (Lines 88-96)
-
-```typescript
-peekPending(sessionDbId: number): PersistentPendingMessage | null {
-  const stmt = this.db.prepare(`
-    SELECT * FROM pending_messages
-    WHERE session_db_id = ? AND status = 'pending'
-    ORDER BY id ASC
-    LIMIT 1
-  `);
-  return stmt.get(sessionDbId) as PersistentPendingMessage | null;
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `status = 'pending'` | Only look at messages not yet being processed | Filters out processing/processed/failed |
-| `ORDER BY id ASC` | Process messages in the order they arrived (FIFO) | Uses auto-increment ID as natural ordering |
-| `LIMIT 1` | Only need one message at a time for the iterator | Returns single oldest pending message |
-| Does NOT change status | Peek is non-destructive; status change happens separately in markProcessing | Allows checking without committing to process |
-
-### `markProcessing()` (Lines 216-224)
-
-```typescript
-markProcessing(messageId: number): void {
-  const now = Date.now();
-  const stmt = this.db.prepare(`
-    UPDATE pending_messages
-    SET status = 'processing', started_processing_at_epoch = ?
-    WHERE id = ? AND status = 'pending'
-  `);
-  stmt.run(now, messageId);
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `status = 'processing'` | Mark this message as "in progress" so other consumers don't pick it up | Prevents duplicate processing |
-| `started_processing_at_epoch = ?` | Track when processing started for stuck detection | If processing takes >5min, considered stuck |
-| `WHERE ... AND status = 'pending'` | Only transition from pending->processing (idempotent safety) | Prevents double-processing race conditions |
-
-### `markProcessed()` (Lines 230-242)
-
-```typescript
-markProcessed(messageId: number): void {
-  const now = Date.now();
-  const stmt = this.db.prepare(`
-    UPDATE pending_messages
-    SET
-      status = 'processed',
-      completed_at_epoch = ?,
-      tool_input = NULL,
-      tool_response = NULL
-    WHERE id = ? AND status = 'processing'
-  `);
-  stmt.run(now, messageId);
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `status = 'processed'` | Message successfully handled, move to terminal state | Marks completion |
-| `completed_at_epoch = ?` | Track when processing finished for metrics/display | Records completion time |
-| `tool_input = NULL, tool_response = NULL` | Large payload data no longer needed after successful processing | Frees space - observations are already saved elsewhere |
-| `WHERE ... AND status = 'processing'` | Only transition from processing->processed | Ensures we only complete messages we actually processed |
-
-### `markFailed()` (Lines 249-274)
-
-```typescript
-markFailed(messageId: number): void {
-  const msg = this.db.prepare('SELECT retry_count FROM pending_messages WHERE id = ?').get(messageId);
-
-  if (msg.retry_count < this.maxRetries) {
-    // Move back to pending for retry
-    const stmt = this.db.prepare(`
-      UPDATE pending_messages
-      SET status = 'pending', retry_count = retry_count + 1, started_processing_at_epoch = NULL
-      WHERE id = ?
-    `);
-  } else {
-    // Max retries exceeded, mark as permanently failed
-    const stmt = this.db.prepare(`
-      UPDATE pending_messages
-      SET status = 'failed', completed_at_epoch = ?
-      WHERE id = ?
-    `);
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Check `retry_count < maxRetries` | Don't retry forever - eventually give up | Implements bounded retry policy (default: 3) |
-| `status = 'pending'` (retry path) | Put message back in queue for another attempt | Allows automatic recovery |
-| `retry_count + 1` | Track how many times we've tried | Increment toward failure threshold |
-| `started_processing_at_epoch = NULL` | Clear the processing timestamp for next attempt | Prevents stuck detection from immediately triggering |
-| `status = 'failed'` (terminal) | Message is permanently broken, stop trying | Prevents infinite retry loops |
-
-### `resetStuckMessages()` (Lines 281-292)
-
-```typescript
-resetStuckMessages(thresholdMs: number): number {
-  const cutoff = thresholdMs === 0 ? Date.now() : Date.now() - thresholdMs;
-
-  const stmt = this.db.prepare(`
-    UPDATE pending_messages
-    SET status = 'pending', started_processing_at_epoch = NULL
-    WHERE status = 'processing' AND started_processing_at_epoch < ?
-  `);
-
-  return result.changes;
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `thresholdMs === 0 ? Date.now()` | Special case: threshold=0 means "reset all processing messages" | Allows forced recovery of all stuck messages |
-| `Date.now() - thresholdMs` | Calculate cutoff time (e.g., 5 minutes ago) | Messages processing longer than this are stuck |
-| `status = 'processing'` condition | Only reset messages actively being processed | Don't touch pending or completed messages |
-| `started_processing_at_epoch < ?` | Processing started before cutoff = stuck | Time-based stuck detection |
-| `SET status = 'pending'` | Move back to queue for retry | Enables automatic recovery |
-| Returns `result.changes` | Caller needs to know how many were recovered | For logging/metrics |
-
-### `getPendingCount()` (Lines 297-304)
-
-```typescript
-getPendingCount(sessionDbId: number): number {
-  const stmt = this.db.prepare(`
-    SELECT COUNT(*) as count FROM pending_messages
-    WHERE session_db_id = ? AND status IN ('pending', 'processing')
-  `);
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `status IN ('pending', 'processing')` | **CRITICAL**: Counts BOTH pending AND processing | Used to decide if generator should keep running |
-| Why include processing? | A message in processing state is still "work to be done" | Prevents generator from stopping while SDK is mid-response |
-
---
-
-## SessionManager (Queue Coordination)
-
-### `queueObservation()` (Lines 181-232)
-
-```typescript
-queueObservation(sessionDbId: number, data: ObservationData): void {
-  // Auto-initialize from database if needed
-  let session = this.sessions.get(sessionDbId);
-  if (!session) {
-    session = this.initializeSession(sessionDbId);
-  }
-
-  // CRITICAL: Persist to database FIRST
-  const message: PendingMessage = { type: 'observation', ... };
-  const messageId = this.getPendingStore().enqueue(sessionDbId, session.claudeSessionId, message);
-
-  // Add to in-memory queue
-  session.pendingMessages.push(message);
-
-  // Notify generator immediately
-  const emitter = this.sessionQueues.get(sessionDbId);
-  emitter?.emit('message');
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Auto-initialize session | Worker may have restarted, need to rebuild in-memory state | Lazy initialization from database |
-| `enqueue()` BEFORE in-memory push | **CRITICAL**: Database is source of truth, survives crashes | Persist-first ensures no data loss |
-| `session.pendingMessages.push()` | In-memory queue for backward compatibility and fast status checks | Mirrors database state in RAM |
-| `emitter?.emit('message')` | Wake up the generator immediately (zero-latency) | Event-driven, no polling needed |
-
-### `getMessageIterator()` (Lines 397-477)
-
-```typescript
-async *getMessageIterator(sessionDbId: number): AsyncIterableIterator<PendingMessageWithId> {
-  while (!session.abortController.signal.aborted) {
-    // Check for pending messages in persistent store
-    const persistentMessage = this.getPendingStore().peekPending(sessionDbId);
-
-    if (!persistentMessage) {
-      // Wait for new message event
-      await new Promise<void>(resolve => {
-        emitter.once('message', messageHandler);
-        session.abortController.signal.addEventListener('abort', abortHandler, { once: true });
-      });
-      continue;
-    }
-
-    // Mark as processing BEFORE yielding
-    this.getPendingStore().markProcessing(persistentMessage.id);
-
-    // Track this message ID for completion marking
-    session.pendingProcessingIds.add(persistentMessage.id);
-
-    // Convert and yield
-    const message: PendingMessageWithId = {
-      _persistentId: persistentMessage.id,
-      _originalTimestamp: persistentMessage.created_at_epoch,
-      ...this.getPendingStore().toPendingMessage(persistentMessage)
-    };
-
-    yield message;
-
-    // Remove from in-memory queue after yielding
-    session.pendingMessages.shift();
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `while (!aborted)` | Keep processing until session ends | Continuous processing loop |
-| `peekPending()` | Check database for work | Non-destructively looks for pending messages |
-| `await new Promise` with event | Block until message arrives (no polling) | Event-driven wake-up saves CPU |
-| `markProcessing()` BEFORE yield | **CRITICAL**: Claim the message before giving to SDK | Prevents race conditions |
-| `pendingProcessingIds.add()` | Track which messages are being processed | So we know what to mark as completed |
-| `_persistentId` field | Attach database ID to in-flight message | Needed for markProcessed() later |
-| `_originalTimestamp` | Preserve original queue time | For accurate observation timestamps when processing backlog |
-| `pendingMessages.shift()` after yield | Keep in-memory queue in sync with database | Mirrors the database state change |
-
---
-
-## SDKAgent (Message Consumer)
-
-### `startSession()` Main Loop (Lines 75-150)
-
-```typescript
-const queryResult = query({
-  prompt: messageGenerator,
-  options: {
-    model: modelId,
-    resume: session.claudeSessionId,  // <-- Session continuity
-    disallowedTools,
-    abortController: session.abortController,
-    pathToClaudeCodeExecutable: claudePath
-  }
-});
-
-for await (const message of queryResult) {
-  if (message.type === 'assistant') {
-    // Process response
-    await this.processSDKResponse(session, textContent, worker, discoveryTokens, originalTimestamp);
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `resume: session.claudeSessionId` | **CRITICAL**: Connect to existing Claude session | Enables session continuity - same transcript across prompts |
-| `for await` loop | Process SDK responses as they arrive | Streaming response handling |
-| `processSDKResponse()` called per response | Parse and save observations/summaries | Database + Chroma sync |
-
-### `createMessageGenerator()` (Lines 202-291)
-
-```typescript
-private async *createMessageGenerator(session: ActiveSession): AsyncIterableIterator<SDKUserMessage> {
-  // Build initial or continuation prompt
-  const initPrompt = isInitPrompt
-    ? buildInitPrompt(...)
-    : buildContinuationPrompt(...);
-
-  // Yield initial prompt
-  yield { type: 'user', message: { role: 'user', content: initPrompt }, session_id: session.claudeSessionId };
-
-  // Consume pending messages
-  for await (const message of this.sessionManager.getMessageIterator(session.sessionDbId)) {
-    if (message.type === 'observation') {
-      const obsPrompt = buildObservationPrompt({ ... });
-      yield { type: 'user', message: { role: 'user', content: obsPrompt } };
-    } else if (message.type === 'summarize') {
-      const summaryPrompt = buildSummaryPrompt({ ... });
-      yield { type: 'user', message: { role: 'user', content: summaryPrompt } };
-    }
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `isInitPrompt` check | First prompt needs full context, subsequent prompts need continuation | Different prompt templates |
-| `yield` initial prompt | Start the SDK conversation | Sends initialization to Claude |
-| `for await ... getMessageIterator` | Pull messages as they become available | Event-driven message consumption |
-| `yield` for each message | Feed observations/summaries to SDK one at a time | SDK processes each and responds |
-
-### `markMessagesProcessed()` (Lines 462-491)
-
-```typescript
-private async markMessagesProcessed(session: ActiveSession, worker: any): Promise<void> {
-  const pendingMessageStore = this.sessionManager.getPendingMessageStore();
-
-  if (session.pendingProcessingIds.size > 0) {
-    for (const messageId of session.pendingProcessingIds) {
-      pendingMessageStore.markProcessed(messageId);
-    }
-    session.pendingProcessingIds.clear();
-    session.earliestPendingTimestamp = null;
-
-    // Cleanup old processed messages
-    const deletedCount = pendingMessageStore.cleanupProcessed(100);
-  }
-
-  // Broadcast status update
-  if (worker && typeof worker.broadcastProcessingStatus === 'function') {
-    worker.broadcastProcessingStatus();
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Loop over `pendingProcessingIds` | Mark ALL messages that were yielded to SDK | Batch completion |
-| `markProcessed()` for each | Transition processing->processed in database | Completes the message lifecycle |
-| `.clear()` | Reset tracking set for next batch | Prepare for next iteration |
-| `earliestPendingTimestamp = null` | Reset timestamp tracking | Next batch gets fresh timestamps |
-| `cleanupProcessed(100)` | Don't keep infinite processed messages | Retention policy |
-| `broadcastProcessingStatus()` | Update UI with new state | SSE broadcast |
-
---
-
-## SessionRoutes (HTTP Entry Points)
-
-### `startGeneratorWithProvider()` (Lines 118-189)
-
-```typescript
-private startGeneratorWithProvider(session, provider, source): void {
-  session.currentProvider = provider;
-
-  session.generatorPromise = agent.startSession(session, this.workerService)
-    .catch(error => {
-      // Mark all processing messages as failed
-      const processingMessages = stmt.all(session.sessionDbId);
-      for (const msg of processingMessages) {
-        pendingStore.markFailed(msg.id);
-      }
-    })
-    .finally(() => {
-      session.generatorPromise = null;
-      session.currentProvider = null;
-      this.workerService.broadcastProcessingStatus();
-
-      // Check if there's more work pending
-      const pendingCount = pendingStore.getPendingCount(sessionDbId);
-      if (pendingCount > 0) {
-        // Auto-restart
-        setTimeout(() => {
-          if (stillExists && !stillExists.generatorPromise) {
-            this.startGeneratorWithProvider(stillExists, this.getSelectedProvider(), 'auto-restart');
-          }
-        }, 0);
-      } else {
-        // Cleanup
-        this.sessionManager.deleteSession(sessionDbId);
-      }
-    });
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| `session.generatorPromise =` | Track that generator is running | Prevents multiple generators per session |
-| `.catch()` with markFailed | If generator crashes, don't lose messages | Marks for retry or permanent failure |
-| `.finally()` | Always cleanup regardless of success/failure | Guaranteed cleanup |
-| `generatorPromise = null` | Allow new generator to start | Clears the "running" flag |
-| `getPendingCount() > 0` | **CRITICAL**: Check if more work arrived while processing | Handles messages queued during SDK call |
-| `setTimeout(..., 0)` | Don't restart synchronously (could cause stack issues) | Deferred restart |
-| `deleteSession()` when no work | Clean up resources | Memory management |
-
-### `ensureGeneratorRunning()` (Lines 90-113)
-
-```typescript
-private ensureGeneratorRunning(sessionDbId: number, source: string): void {
-  const session = this.sessionManager.getSession(sessionDbId);
-  if (!session) return;
-
-  const selectedProvider = this.getSelectedProvider();
-
-  // Start generator if not running
-  if (!session.generatorPromise) {
-    this.startGeneratorWithProvider(session, selectedProvider, source);
-    return;
-  }
-
-  // Generator is running - check if provider changed
-  if (session.currentProvider && session.currentProvider !== selectedProvider) {
-    // Let current generator finish, next one will use new provider
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Check `!generatorPromise` | Only start if not already running | Prevents duplicate generators |
-| Start generator if not running | Ensure messages get processed | Lazy generator startup |
-| Provider change detection | Allow switching providers mid-session | Graceful provider transition |
-
---
-
-## WorkerService (Orchestrator)
-
-### `initializeBackground()` Stuck Message Recovery (Lines 627-633)
-
-```typescript
-// Recover stuck messages from previous crashes
-const STUCK_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
-const resetCount = pendingStore.resetStuckMessages(STUCK_THRESHOLD_MS);
-if (resetCount > 0) {
-  logger.info('SYSTEM', `Recovered ${resetCount} stuck messages from previous session`);
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Called at startup | Worker may have crashed while messages were processing | Recovery mechanism |
-| 5 minute threshold | If processing >5min, something went wrong | Reasonable timeout for SDK calls |
-| Reset to pending | Give stuck messages another chance | Automatic retry |
-
-### `processPendingQueues()` (Lines 747-811)
-
-```typescript
-async processPendingQueues(sessionLimit: number = 10): Promise<Result> {
-  const orphanedSessionIds = pendingStore.getSessionsWithPendingMessages();
-
-  for (const sessionDbId of orphanedSessionIds) {
-    // Skip if session already has active generator
-    const existingSession = this.sessionManager.getSession(sessionDbId);
-    if (existingSession?.generatorPromise) {
-      result.sessionsSkipped++;
-      continue;
-    }
-
-    // Initialize session and start SDK agent
-    const session = this.sessionManager.initializeSession(sessionDbId);
-    this.startSessionWithAutoRestart(session, getPendingCount, 'startup-recovery');
-  }
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Called at startup | Resume work interrupted by crash/restart | Auto-recovery |
-| `getSessionsWithPendingMessages()` | Find sessions that have orphaned work | Database query |
-| Skip if generator running | Don't start duplicate processors | Race condition prevention |
-| `startSessionWithAutoRestart()` | Start processing with auto-restart logic | Shares code with SessionRoutes |
-
-### `startSessionWithAutoRestart()` (Lines 696-739)
-
-```typescript
-private startSessionWithAutoRestart(session, getPendingCount, source): void {
-  session.generatorPromise = this.sdkAgent.startSession(session, this)
-    .catch(error => { ... })
-    .finally(() => {
-      session.generatorPromise = null;
-      this.broadcastProcessingStatus();
-
-      const stillPending = getPendingCount(sid);
-      if (stillPending > 0) {
-        // Recursive restart
-        setTimeout(() => {
-          const stillExists = this.sessionManager.getSession(sid);
-          if (stillExists && !stillExists.generatorPromise) {
-            this.startSessionWithAutoRestart(stillExists, getPendingCount, 'auto-restart');
-          }
-        }, 0);
-      } else {
-        // Cleanup
-        this.sessionManager.deleteSession(sid);
-      }
-    });
-}
-```
-
-| Line | The Reason Behind This | What It Actually Does |
-|------|------------------------|----------------------|
-| Same pattern as SessionRoutes | **DRY**: Shared auto-restart logic | Prevents code duplication |
-| Recursive restart | Keep processing until queue is empty | Ensures all messages processed |
-| Check `stillExists` before restart | Session might have been deleted | Safety check |
-
---
-
-## Critical Flow: How a Message Gets Stuck in "Processing"
-
-### The Problem
-
-Messages can get stuck in `status = 'processing'` if:
-
-1. **SDK call hangs indefinitely** - The Agent SDK query never returns
-2. **Worker crashes mid-processing** - Process dies before markProcessed()
-3. **Exception in processSDKResponse()** - Error prevents markProcessed() from running
-
-### The Flow
-
-```
-1. queueObservation() called
-   └─► enqueue() → status = 'pending'
-
-2. getMessageIterator() picks up message
-   └─► markProcessing() → status = 'processing' ✓
-   └─► pendingProcessingIds.add(id)
-   └─► yield message to SDK
-
-3. SDK processes and returns response
-   └─► processSDKResponse() called
-       └─► Parse observations/summaries
-       └─► Store to database
-       └─► markMessagesProcessed()
-           └─► markProcessed() → status = 'processed' ✓
-
-IF STEP 3 FAILS OR HANGS:
-   └─► Message stays in 'processing' forever
-   └─► Recovery: resetStuckMessages() after 5 minutes
-```
-
-### Why Processing Messages Can Get "Lost"
-
-**Race Condition in getMessageIterator():**
-
-```typescript
-// Lines 445-446 in SessionManager
-this.getPendingStore().markProcessing(persistentMessage.id);
-session.pendingProcessingIds.add(persistentMessage.id);
-```
-
-The message is marked as `processing` BEFORE being yielded. If the SDK hangs or crashes AFTER this line but BEFORE processSDKResponse completes, the message is stuck.
-
-**Protection Mechanisms:**
-
-1. `pendingProcessingIds` tracks what's in-flight
-2. `markFailed()` in catch handler marks for retry
-3. `resetStuckMessages()` at startup cleans up old stuck messages
-
---
-
-## Recovery Mechanisms
-
-### 1. Startup Recovery (Worker crashes)
-
-```typescript
-// In initializeBackground()
-const resetCount = pendingStore.resetStuckMessages(STUCK_THRESHOLD_MS);
-```
-
- Runs when worker starts
- Finds messages stuck in `processing` for >5 minutes
- Resets them to `pending` for retry
-
-### 2. Generator Error Recovery
-
-```typescript
-// In startGeneratorWithProvider() catch handler
-for (const msg of processingMessages) {
-  pendingStore.markFailed(msg.id);
-}
-```
-
- Runs when SDK call throws
- Marks processing messages as failed (which may reset to pending if retries remain)
-
-### 3. Auto-Restart Recovery
-
-```typescript
-// In startGeneratorWithProvider() finally handler
-if (pendingCount > 0) {
-  setTimeout(() => startGeneratorWithProvider(...), 0);
-}
-```
-
- Runs after every generator completes
- Checks for pending work
- Starts new generator if work remains
-
-### 4. Manual Recovery (UI)
-
-```typescript
-// PendingMessageStore methods
-retryMessage(messageId)      // Reset specific message to pending
-retryAllStuck(thresholdMs)   // Reset all stuck messages
-abortMessage(messageId)      // Delete message from queue
-```
-
---
-
-## Summary of Potential Issues
-
-| Issue | Cause | Mitigation |
-|-------|-------|------------|
-| Message stuck in processing | SDK hang, crash during processing | `resetStuckMessages()` at startup |
-| Duplicate processing | Race condition on message claim | `markProcessing()` with `WHERE status = 'pending'` |
-| Lost messages | Crash before enqueue | DB persist BEFORE in-memory push |
-| Generator never starts | No call to `ensureGeneratorRunning()` | Called by every HTTP handler |
-| Generator exits early | Empty queue check race | `finally` handler checks and restarts |
-| Infinite retry | Repeated failures | `maxRetries` limit (default: 3) |
-
---
-
-## Diagnostic Queries
-
-Check for stuck messages:
-```sql
-SELECT * FROM pending_messages
-WHERE status = 'processing'
-AND started_processing_at_epoch < (strftime('%s', 'now') * 1000 - 300000);
-```
-
-Check queue depth by session:
-```sql
-SELECT session_db_id, status, COUNT(*)
-FROM pending_messages
-GROUP BY session_db_id, status;
-```
-
-Check retry counts:
-```sql
-SELECT id, message_type, retry_count, status
-FROM pending_messages
-WHERE retry_count > 0;
-```
@@ -1,4 +1,12 @@
+<p align="center">
+  Official $CMEM Links: 
+  <a href="https://bags.fm/2TsmuYUrsctE57VLckZBYEEzdokUF8j8e1GavekWBAGS">Bags.fm</a> •
+  <a href="https://jup.ag/tokens/2TsmuYUrsctE57VLckZBYEEzdokUF8j8e1GavekWBAGS">Jupiter</a> •
+  <a href="https://photon-sol.tinyastro.io/en/lp/6MzFAkWnac6GSK1EdFX93dZeukGfzrFq4UHWarhGSQyd">Photon</a> •
+  <a href="https://dexscreener.com/solana/6mzfakwnac6gsk1edfx93dzeukgfzrfq4uhwarhgsqyd">DEXScreener</a>
+</p>

+<p align="center">Official CA: 2TsmuYUrsctE57VLckZBYEEzdokUF8j8e1GavekWBAGS (on Solana)</p>

 <h1 align="center">
  <br>
@@ -14,6 +22,7 @@

 <p align="center">
  <a href="docs/i18n/README.zh.md">🇨🇳 中文</a> •
+  <a href="docs/i18n/README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="docs/i18n/README.ja.md">🇯🇵 日本語</a> •
  <a href="docs/i18n/README.pt-br.md">🇧🇷 Português</a> •
  <a href="docs/i18n/README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +42,7 @@
  <a href="docs/i18n/README.th.md">🇹🇭 ไทย</a> •
  <a href="docs/i18n/README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="docs/i18n/README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="docs/i18n/README.ur.md">🇵🇰 اردو</a> •
  <a href="docs/i18n/README.ro.md">🇷🇴 Română</a> •
  <a href="docs/i18n/README.sv.md">🇸🇪 Svenska</a> •
  <a href="docs/i18n/README.it.md">🇮🇹 Italiano</a> •
@@ -101,9 +111,9 @@
 Start a new Claude Code session in the terminal and enter the following commands:

 ```
-> /plugin marketplace add thedotmack/claude-mem
+/plugin marketplace add thedotmack/claude-mem

-> /plugin install claude-mem
+/plugin install claude-mem
 ```

 Restart Claude Code. Context from previous sessions will automatically appear in new sessions.
@@ -125,7 +135,7 @@ Restart Claude Code. Context from previous sessions will automatically appear in

 ## Documentation

-📚 **[View Full Documentation](docs/)** - Browse markdown docs on GitHub
+📚 **[View Full Documentation](https://docs.claude-mem.ai/)** - Browse on official website

 ### Getting Started

@@ -174,7 +184,7 @@ See [Architecture Overview](https://docs.claude-mem.ai/architecture/overview) fo

 ## MCP Search Tools

-Claude-Mem provides intelligent memory search through **4 MCP tools** following a token-efficient **3-layer workflow pattern**:
+Claude-Mem provides intelligent memory search through **5 MCP tools** following a token-efficient **3-layer workflow pattern**:

 **The 3-Layer Workflow:**

@@ -187,6 +197,7 @@ Claude-Mem provides intelligent memory search through **4 MCP tools** following
 - Start with `search` to get an index of results
 - Use `timeline` to see what was happening around specific observations
 - Use `get_observations` to fetch full details for relevant IDs
+- Use `save_memory` to manually store important information
 - **~10x token savings** by filtering before fetching details

 **Available MCP Tools:**
@@ -194,7 +205,8 @@ Claude-Mem provides intelligent memory search through **4 MCP tools** following
 1. **`search`** - Search memory index with full-text queries, filters by type/date/project
 2. **`timeline`** - Get chronological context around a specific observation or query
 3. **`get_observations`** - Fetch full observation details by IDs (always batch multiple IDs)
-4. **`__IMPORTANT`** - Workflow documentation (always visible to Claude)
+4. **`save_memory`** - Manually save a memory/observation for semantic search
+5. **`__IMPORTANT`** - Workflow documentation (always visible to Claude)

 **Example Usage:**

@@ -206,6 +218,9 @@ search(query="authentication bug", type="bugfix", limit=10)

 // Step 3: Fetch full details
 get_observations(ids=[123, 456])
+
+// Save important information manually
+save_memory(text="API requires auth header X-API-Key", title="API Auth")
 ```

 See [Search Tools Guide](https://docs.claude-mem.ai/usage/search-tools) for detailed examples.
@@ -228,6 +243,17 @@ See **[Beta Features Documentation](https://docs.claude-mem.ai/beta-features)**
 - **uv**: Python package manager for vector search (auto-installed if missing)
 - **SQLite 3**: For persistent storage (bundled)

+---
+### Windows Setup Notes
+
+If you see an error like:
+
+```powershell
+npm : The term 'npm' is not recognized as the name of a cmdlet
+```
+
+Make sure Node.js and npm are installed and added to your PATH. Download the latest Node.js installer from https://nodejs.org and restart your terminal after installation.
+
 ---

 ## Configuration
@@ -299,6 +325,8 @@ See the [LICENSE](LICENSE) file for full details.
 - **Documentation**: [docs/](docs/)
 - **Issues**: [GitHub Issues](https://github.com/thedotmack/claude-mem/issues)
 - **Repository**: [github.com/thedotmack/claude-mem](https://github.com/thedotmack/claude-mem)
+- **Official X Account**: [@Claude_Memory](https://x.com/Claude_Memory)
+- **Official Discord**: [Join Discord](https://discord.com/invite/J4wttp9vDu)
 - **Author**: Alex Newman ([@thedotmack](https://github.com/thedotmack))

 ---
@@ -0,0 +1,6 @@
+{
+    "scripts": {
+        "setup": "cp ../settings.local.json .claude/settings.local.json && npm install",
+        "run": "npm run build-and-sync"
+    }
+}
@@ -1,192 +0,0 @@
-# Common utility functions for Cursor hooks (PowerShell)
-# Dot-source this file in hook scripts: . "$PSScriptRoot\common.ps1"
-# Note: ErrorActionPreference should be set in each script, not globally here
-
-# Get worker port from settings with validation
-function Get-WorkerPort {
-    $settingsPath = Join-Path $env:USERPROFILE ".claude-mem\settings.json"
-    $port = 37777
-
-    if (Test-Path $settingsPath) {
-        try {
-            $settings = Get-Content $settingsPath -Raw | ConvertFrom-Json
-            if ($settings.CLAUDE_MEM_WORKER_PORT) {
-                $parsedPort = [int]$settings.CLAUDE_MEM_WORKER_PORT
-                if ($parsedPort -ge 1 -and $parsedPort -le 65535) {
-                    $port = $parsedPort
-                }
-            }
-        } catch {
-            # Ignore parse errors, use default
-        }
-    }
-
-    return $port
-}
-
-# Ensure worker is running with retries
-function Test-WorkerReady {
-    param(
-        [int]$Port = 37777,
-        [int]$MaxRetries = 75
-    )
-
-    for ($i = 0; $i -lt $MaxRetries; $i++) {
-        try {
-            $response = Invoke-RestMethod -Uri "http://127.0.0.1:$Port/api/readiness" -Method Get -TimeoutSec 1 -ErrorAction Stop
-            return $true
-        } catch {
-            Start-Sleep -Milliseconds 200
-        }
-    }
-
-    return $false
-}
-
-# Get project name from workspace root
-function Get-ProjectName {
-    param([string]$WorkspaceRoot)
-
-    if ([string]::IsNullOrEmpty($WorkspaceRoot)) {
-        return "unknown-project"
-    }
-
-    # Handle Windows drive root (e.g., "C:\")
-    if ($WorkspaceRoot -match '^([A-Za-z]):\\?$') {
-        return "drive-$($Matches[1].ToUpper())"
-    }
-
-    $projectName = Split-Path $WorkspaceRoot -Leaf
-    if ([string]::IsNullOrEmpty($projectName)) {
-        return "unknown-project"
-    }
-
-    return $projectName
-}
-
-# URL encode a string
-function Get-UrlEncodedString {
-    param([string]$String)
-
-    if ([string]::IsNullOrEmpty($String)) {
-        return ""
-    }
-
-    return [System.Uri]::EscapeDataString($String)
-}
-
-# Check if string is empty or null
-function Test-IsEmpty {
-    param([string]$String)
-
-    return [string]::IsNullOrEmpty($String) -or $String -eq "null" -or $String -eq "empty"
-}
-
-# Safely read JSON from stdin with error handling
-function Read-JsonInput {
-    try {
-        $input = [Console]::In.ReadToEnd()
-        if ([string]::IsNullOrEmpty($input)) {
-            return @{}
-        }
-        return $input | ConvertFrom-Json -ErrorAction Stop
-    } catch {
-        return @{}
-    }
-}
-
-# Safely get JSON field with fallback
-function Get-JsonField {
-    param(
-        [PSObject]$Json,
-        [string]$Field,
-        [string]$Fallback = ""
-    )
-
-    if ($null -eq $Json) {
-        return $Fallback
-    }
-
-    # Handle array access syntax (e.g., "workspace_roots[0]")
-    if ($Field -match '^(.+)\[(\d+)\]$') {
-        $arrayField = $Matches[1]
-        $index = [int]$Matches[2]
-
-        if ($Json.PSObject.Properties.Name -contains $arrayField) {
-            $array = $Json.$arrayField
-            if ($null -ne $array -and $array.Count -gt $index) {
-                $value = $array[$index]
-                if (-not (Test-IsEmpty $value)) {
-                    return $value
-                }
-            }
-        }
-        return $Fallback
-    }
-
-    # Simple field access
-    if ($Json.PSObject.Properties.Name -contains $Field) {
-        $value = $Json.$Field
-        if (-not (Test-IsEmpty $value)) {
-            return $value
-        }
-    }
-
-    return $Fallback
-}
-
-# Convert object to JSON string (compact)
-function ConvertTo-JsonCompact {
-    param([object]$Object)
-
-    return $Object | ConvertTo-Json -Compress -Depth 10
-}
-
-# Send HTTP POST request (fire-and-forget style)
-function Send-HttpPostAsync {
-    param(
-        [string]$Uri,
-        [object]$Body
-    )
-
-    try {
-        $bodyJson = ConvertTo-JsonCompact $Body
-        Start-Job -ScriptBlock {
-            param($u, $b)
-            try {
-                Invoke-RestMethod -Uri $u -Method Post -Body $b -ContentType "application/json" -TimeoutSec 5 -ErrorAction SilentlyContinue | Out-Null
-            } catch {}
-        } -ArgumentList $Uri, $bodyJson | Out-Null
-    } catch {
-        # Ignore errors - fire and forget
-    }
-}
-
-# Send HTTP POST request (synchronous)
-function Send-HttpPost {
-    param(
-        [string]$Uri,
-        [object]$Body
-    )
-
-    try {
-        $bodyJson = ConvertTo-JsonCompact $Body
-        Invoke-RestMethod -Uri $u -Method Post -Body $bodyJson -ContentType "application/json" -TimeoutSec 5 -ErrorAction SilentlyContinue | Out-Null
-    } catch {
-        # Ignore errors
-    }
-}
-
-# Get HTTP response
-function Get-HttpResponse {
-    param(
-        [string]$Uri,
-        [int]$TimeoutSec = 5
-    )
-
-    try {
-        return Invoke-RestMethod -Uri $Uri -Method Get -TimeoutSec $TimeoutSec -ErrorAction Stop
-    } catch {
-        return $null
-    }
-}
@@ -1,140 +0,0 @@
-#!/bin/bash
-# Common utility functions for Cursor hooks
-# Source this file in hook scripts: source "$(dirname "$0")/common.sh"
-
-# Check if required commands exist
-check_dependencies() {
-  local missing=()
-  
-  if ! command -v jq >/dev/null 2>&1; then
-    missing+=("jq")
-  fi
-  
-  if ! command -v curl >/dev/null 2>&1; then
-    missing+=("curl")
-  fi
-  
-  if [ ${#missing[@]} -gt 0 ]; then
-    echo "Error: Missing required dependencies: ${missing[*]}" >&2
-    echo "Please install: ${missing[*]}" >&2
-    return 1
-  fi
-  
-  return 0
-}
-
-# Safely read JSON from stdin with error handling
-read_json_input() {
-  local input
-  input=$(cat 2>/dev/null || echo "{}")
-  
-  # Validate JSON
-  if ! echo "$input" | jq empty 2>/dev/null; then
-    # Invalid JSON - return empty object
-    echo "{}"
-    return 1
-  fi
-  
-  echo "$input"
-  return 0
-}
-
-# Get worker port from settings with validation
-get_worker_port() {
-  local data_dir="${HOME}/.claude-mem"
-  local settings_file="${data_dir}/settings.json"
-  local port="37777"
-  
-  if [ -f "$settings_file" ]; then
-    local parsed_port
-    parsed_port=$(jq -r '.CLAUDE_MEM_WORKER_PORT // "37777"' "$settings_file" 2>/dev/null || echo "37777")
-    
-    # Validate port is a number between 1-65535
-    if [[ "$parsed_port" =~ ^[0-9]+$ ]] && [ "$parsed_port" -ge 1 ] && [ "$parsed_port" -le 65535 ]; then
-      port="$parsed_port"
-    fi
-  fi
-  
-  echo "$port"
-}
-
-# Ensure worker is running with retries
-ensure_worker_running() {
-  local port="${1:-37777}"
-  local max_retries="${2:-75}"  # 15 seconds total (75 * 0.2s)
-  local retry_count=0
-  
-  while [ $retry_count -lt $max_retries ]; do
-    if curl -s -f "http://127.0.0.1:${port}/api/readiness" >/dev/null 2>&1; then
-      return 0
-    fi
-    sleep 0.2
-    retry_count=$((retry_count + 1))
-  done
-  
-  return 1
-}
-
-# URL encode a string (basic implementation)
-url_encode() {
-  local string="$1"
-  # Use printf to URL encode
-  printf '%s' "$string" | jq -sRr @uri
-}
-
-# Get project name from workspace root
-get_project_name() {
-  local workspace_root="$1"
-  
-  if [ -z "$workspace_root" ]; then
-    echo "unknown-project"
-    return
-  fi
-  
-  # Use basename, fallback to unknown-project
-  local project_name
-  project_name=$(basename "$workspace_root" 2>/dev/null || echo "unknown-project")
-  
-  # Handle edge case: empty basename (root directory)
-  if [ -z "$project_name" ]; then
-    # Check if it's a Windows drive root
-    if [[ "$workspace_root" =~ ^[A-Za-z]:\\?$ ]]; then
-      local drive_letter
-      drive_letter=$(echo "$workspace_root" | grep -oE '^[A-Za-z]' | tr '[:lower:]' '[:upper:]')
-      echo "drive-${drive_letter}"
-    else
-      echo "unknown-project"
-    fi
-  else
-    echo "$project_name"
-  fi
-}
-
-# Safely extract JSON field with fallback
-# Supports both simple fields (e.g., "conversation_id") and array access (e.g., "workspace_roots[0]")
-json_get() {
-  local json="$1"
-  local field="$2"
-  local fallback="${3:-}"
-  
-  local value
-  
-  # Handle array access syntax (e.g., "workspace_roots[0]")
-  if [[ "$field" =~ ^(.+)\[([0-9]+)\]$ ]]; then
-    local array_field="${BASH_REMATCH[1]}"
-    local index="${BASH_REMATCH[2]}"
-    value=$(echo "$json" | jq -r --arg f "$array_field" --arg i "$index" --arg fb "$fallback" '.[$f] // [] | .[$i | tonumber] // $fb' 2>/dev/null || echo "$fallback")
-  else
-    # Simple field access
-    value=$(echo "$json" | jq -r --arg f "$field" --arg fb "$fallback" '.[$f] // $fb' 2>/dev/null || echo "$fallback")
-  fi
-  
-  echo "$value"
-}
-
-# Check if string is empty or null
-is_empty() {
-  local str="$1"
-  [ -z "$str" ] || [ "$str" = "null" ] || [ "$str" = "empty" ]
-}
-
@@ -1,74 +0,0 @@
-# Context Hook for Cursor (beforeSubmitPrompt) - PowerShell
-# Ensures worker is running and refreshes context before prompt submission
-#
-# Context is updated in BOTH places:
-# - Here (beforeSubmitPrompt): Fresh context at session start
-# - stop hook (session-summary.ps1): Updated context after observations are made
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# Source common utilities
-$commonPath = Join-Path $PSScriptRoot "common.ps1"
-if (Test-Path $commonPath) {
-    . $commonPath
-} else {
-    Write-Output '{"continue": true}'
-    exit 0
-}
-
-# Read JSON input from stdin
-$input = Read-JsonInput
-
-# Extract workspace root
-$workspaceRoot = Get-JsonField $input "workspace_roots[0]" ""
-if (Test-IsEmpty $workspaceRoot) {
-    $workspaceRoot = Get-Location
-}
-
-# Get project name
-$projectName = Get-ProjectName $workspaceRoot
-
-# Get worker port from settings
-$workerPort = Get-WorkerPort
-
-# Ensure worker is running (with retries)
-# This primes the worker before the session starts
-if (Test-WorkerReady -Port $workerPort) {
-    # Refresh context file with latest observations
-    $projectEncoded = Get-UrlEncodedString $projectName
-    $contextUri = "http://127.0.0.1:$workerPort/api/context/inject?project=$projectEncoded"
-    $context = Get-HttpResponse -Uri $contextUri
-
-    if (-not [string]::IsNullOrEmpty($context)) {
-        $rulesDir = Join-Path $workspaceRoot ".cursor\rules"
-        $rulesFile = Join-Path $rulesDir "claude-mem-context.mdc"
-
-        # Create rules directory if it doesn't exist
-        if (-not (Test-Path $rulesDir)) {
-            New-Item -ItemType Directory -Path $rulesDir -Force | Out-Null
-        }
-
-        # Write context as a Cursor rule with alwaysApply: true
-        $ruleContent = @"
---
-alwaysApply: true
-description: "Claude-mem context from past sessions (auto-updated)"
---
-
-# Memory Context from Past Sessions
-
-The following context is from claude-mem, a persistent memory system that tracks your coding sessions.
-
-$context
-
---
-*Updated after last session. Use claude-mem's MCP search tools for more detailed queries.*
-"@
-
-        Set-Content -Path $rulesFile -Value $ruleContent -Encoding UTF8 -Force
-    }
-}
-
-# Allow prompt to continue
-Write-Output '{"continue": true}'
-exit 0
@@ -1,70 +0,0 @@
-#!/bin/bash
-# Context Hook for Cursor (beforeSubmitPrompt)
-# Ensures worker is running and refreshes context before prompt submission
-#
-# Context is updated in BOTH places:
-# - Here (beforeSubmitPrompt): Fresh context at session start
-# - stop hook (session-summary.sh): Updated context after observations are made
-
-# Source common utilities
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/common.sh" 2>/dev/null || {
-  echo '{"continue": true}'
-  exit 0
-}
-
-# Check dependencies (non-blocking)
-check_dependencies >/dev/null 2>&1 || true
-
-# Read JSON input from stdin
-input=$(read_json_input)
-
-# Extract workspace root
-workspace_root=$(json_get "$input" "workspace_roots[0]" "")
-if is_empty "$workspace_root"; then
-  workspace_root=$(pwd)
-fi
-
-# Get project name
-project_name=$(get_project_name "$workspace_root")
-
-# Get worker port from settings
-worker_port=$(get_worker_port)
-
-# Ensure worker is running (with retries)
-# This primes the worker before the session starts
-if ensure_worker_running "$worker_port" >/dev/null 2>&1; then
-  # Refresh context file with latest observations
-  project_encoded=$(url_encode "$project_name")
-  context=$(curl -s -f "http://127.0.0.1:${worker_port}/api/context/inject?project=${project_encoded}" 2>/dev/null || echo "")
-  
-  if [ -n "$context" ]; then
-    rules_dir="${workspace_root}/.cursor/rules"
-    rules_file="${rules_dir}/claude-mem-context.mdc"
-    
-    # Create rules directory if it doesn't exist
-    mkdir -p "$rules_dir" 2>/dev/null || true
-    
-    # Write context as a Cursor rule with alwaysApply: true
-    cat > "$rules_file" 2>/dev/null << EOF
---
-alwaysApply: true
-description: "Claude-mem context from past sessions (auto-updated)"
---
-
-# Memory Context from Past Sessions
-
-The following context is from claude-mem, a persistent memory system that tracks your coding sessions.
-
-${context}
-
---
-*Updated after last session. Use claude-mem's MCP search tools for more detailed queries.*
-EOF
-  fi
-fi
-
-# Allow prompt to continue
-echo '{"continue": true}'
-exit 0
-
@@ -1,71 +0,0 @@
-#!/bin/bash
-# Installation script for claude-mem Cursor hooks
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-INSTALL_TYPE="${1:-user}"  # 'user' (recommended) or 'project'
-
-echo "Installing claude-mem Cursor hooks (${INSTALL_TYPE} level)..."
-
-case "$INSTALL_TYPE" in
-  "project")
-    if [ ! -d ".cursor" ]; then
-      mkdir -p .cursor
-    fi
-    TARGET_DIR=".cursor"
-    HOOKS_DIR=".cursor/hooks"
-    ;;
-  "user")
-    TARGET_DIR="${HOME}/.cursor"
-    HOOKS_DIR="${HOME}/.cursor/hooks"
-    ;;
-  *)
-    echo "Invalid install type: $INSTALL_TYPE"
-    echo "Usage: $0 [user (recommended)|project]"
-    exit 1
-    ;;
-esac
-
-# Create hooks directory
-mkdir -p "$HOOKS_DIR"
-
-# Copy hook scripts
-echo "Copying hook scripts..."
-cp "$SCRIPT_DIR"/*.sh "$HOOKS_DIR/"
-chmod +x "$HOOKS_DIR"/*.sh
-
-# Copy hooks.json
-echo "Copying hooks.json..."
-cp "$SCRIPT_DIR/hooks.json" "$TARGET_DIR/hooks.json"
-
-# Update paths in hooks.json if needed
-# Use portable sed approach that works on both BSD (macOS) and GNU (Linux) sed
-if [ "$INSTALL_TYPE" = "project" ]; then
-  # For project-level, paths should be relative
-  # Create temp file, modify, then move (portable across sed variants)
-  tmp_file=$(mktemp)
-  sed 's|\./cursor-hooks/|\./\.cursor/hooks/|g' "$TARGET_DIR/hooks.json" > "$tmp_file"
-  mv "$tmp_file" "$TARGET_DIR/hooks.json"
-else
-  # For user-level, use absolute paths
-  tmp_file=$(mktemp)
-  sed "s|\./cursor-hooks/|${HOOKS_DIR}/|g" "$TARGET_DIR/hooks.json" > "$tmp_file"
-  mv "$tmp_file" "$TARGET_DIR/hooks.json"
-fi
-
-echo ""
-echo "✓ Installation complete!"
-echo ""
-echo "Hooks installed to: $TARGET_DIR/hooks.json"
-echo "Scripts installed to: $HOOKS_DIR"
-echo ""
-echo "Next steps:"
-echo "1. Ensure claude-mem worker is running:"
-echo "   cd ~/.claude/plugins/marketplaces/thedotmack && npm run worker:start"
-echo ""
-echo "2. Restart Cursor to load the hooks"
-echo ""
-echo "3. Check Cursor Settings → Hooks tab to verify hooks are active"
-echo ""
-
@@ -1,126 +0,0 @@
-# Save File Edit Hook for Cursor (PowerShell)
-# Captures file edits made by the agent
-# Maps file edits to claude-mem observations
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# Source common utilities
-$commonPath = Join-Path $PSScriptRoot "common.ps1"
-if (Test-Path $commonPath) {
-    . $commonPath
-} else {
-    Write-Warning "common.ps1 not found, using fallback functions"
-    exit 0
-}
-
-# Read JSON input from stdin with error handling
-$input = Read-JsonInput
-
-# Extract common fields with safe fallbacks
-$conversationId = Get-JsonField $input "conversation_id" ""
-$generationId = Get-JsonField $input "generation_id" ""
-$filePath = Get-JsonField $input "file_path" ""
-$workspaceRoot = Get-JsonField $input "workspace_roots[0]" ""
-
-# Fallback to current directory if no workspace root
-if (Test-IsEmpty $workspaceRoot) {
-    $workspaceRoot = Get-Location
-}
-
-# Exit if no file_path
-if (Test-IsEmpty $filePath) {
-    exit 0
-}
-
-# Use conversation_id as session_id, fallback to generation_id
-$sessionId = $conversationId
-if (Test-IsEmpty $sessionId) {
-    $sessionId = $generationId
-}
-
-# Exit if no session_id available
-if (Test-IsEmpty $sessionId) {
-    exit 0
-}
-
-# Get worker port from settings with validation
-$workerPort = Get-WorkerPort
-
-# Extract edits array, defaulting to [] if invalid
-$edits = @()
-if ($input.PSObject.Properties.Name -contains "edits") {
-    $edits = $input.edits
-    if ($null -eq $edits -or -not ($edits -is [array])) {
-        $edits = @()
-    }
-}
-
-# Exit if no edits
-if ($edits.Count -eq 0) {
-    exit 0
-}
-
-# Create a summary of the edits for the observation
-$editSummaries = @()
-foreach ($edit in $edits) {
-    $oldStr = ""
-    $newStr = ""
-
-    if ($edit.PSObject.Properties.Name -contains "old_string") {
-        $oldStr = $edit.old_string
-        if ($oldStr.Length -gt 50) {
-            $oldStr = $oldStr.Substring(0, 50) + "..."
-        }
-    }
-
-    if ($edit.PSObject.Properties.Name -contains "new_string") {
-        $newStr = $edit.new_string
-        if ($newStr.Length -gt 50) {
-            $newStr = $newStr.Substring(0, 50) + "..."
-        }
-    }
-
-    $editSummaries += "$oldStr → $newStr"
-}
-
-$editSummary = $editSummaries -join "; "
-if ([string]::IsNullOrEmpty($editSummary)) {
-    $editSummary = "File edited"
-}
-
-# Treat file edits as a "write_file" tool usage
-$toolInput = @{
-    file_path = $filePath
-    edits = $edits
-}
-
-$toolResponse = @{
-    success = $true
-    summary = $editSummary
-}
-
-$payload = @{
-    contentSessionId = $sessionId
-    tool_name = "write_file"
-    tool_input = $toolInput
-    tool_response = $toolResponse
-    cwd = $workspaceRoot
-}
-
-# Ensure worker is running (with retries like claude-mem hooks)
-if (-not (Test-WorkerReady -Port $workerPort)) {
-    # Worker not ready - exit gracefully (don't block Cursor)
-    exit 0
-}
-
-# Send observation to claude-mem worker (fire-and-forget)
-$uri = "http://127.0.0.1:$workerPort/api/sessions/observations"
-
-try {
-    $bodyJson = ConvertTo-JsonCompact $payload
-    Invoke-RestMethod -Uri $uri -Method Post -Body $bodyJson -ContentType "application/json" -TimeoutSec 5 -ErrorAction SilentlyContinue | Out-Null
-} catch {
-    # Ignore errors - don't block Cursor
-}
-
-exit 0
@@ -1,112 +0,0 @@
-#!/bin/bash
-# Save File Edit Hook for Cursor
-# Captures file edits made by the agent
-# Maps file edits to claude-mem observations
-
-# Source common utilities
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/common.sh" 2>/dev/null || {
-  echo "Warning: common.sh not found, using fallback functions" >&2
-}
-
-# Check dependencies (non-blocking)
-check_dependencies >/dev/null 2>&1 || true
-
-# Read JSON input from stdin with error handling
-input=$(read_json_input)
-
-# Extract common fields with safe fallbacks
-conversation_id=$(json_get "$input" "conversation_id" "")
-generation_id=$(json_get "$input" "generation_id" "")
-file_path=$(json_get "$input" "file_path" "")
-workspace_root=$(json_get "$input" "workspace_roots[0]" "")
-
-# Fallback to current directory if no workspace root
-if is_empty "$workspace_root"; then
-  workspace_root=$(pwd)
-fi
-
-# Exit if no file_path
-if is_empty "$file_path"; then
-  exit 0
-fi
-
-# Use conversation_id as session_id, fallback to generation_id
-session_id="$conversation_id"
-if is_empty "$session_id"; then
-  session_id="$generation_id"
-fi
-
-# Exit if no session_id available
-if is_empty "$session_id"; then
-  exit 0
-fi
-
-# Get worker port from settings with validation
-worker_port=$(get_worker_port)
-
-# Extract edits array, defaulting to [] if invalid
-edits=$(echo "$input" | jq -c '.edits // []' 2>/dev/null || echo "[]")
-
-# Validate edits is a valid JSON array
-if ! echo "$edits" | jq 'type == "array"' 2>/dev/null | grep -q true; then
-  edits="[]"
-fi
-
-# Exit if no edits
-if [ "$edits" = "[]" ] || is_empty "$edits"; then
-  exit 0
-fi
-
-# Create a summary of the edits for the observation (with error handling)
-edit_summary=$(echo "$edits" | jq -r '[.[] | "\(.old_string[0:50] // "")... → \(.new_string[0:50] // "")..."] | join("; ")' 2>/dev/null || echo "File edited")
-
-# Treat file edits as a "write_file" tool usage
-tool_input=$(jq -n \
-  --arg path "$file_path" \
-  --argjson edits "$edits" \
-  '{
-    file_path: $path,
-    edits: $edits
-  }' 2>/dev/null || echo '{}')
-
-tool_response=$(jq -n \
-  --arg summary "$edit_summary" \
-  '{
-    success: true,
-    summary: $summary
-  }' 2>/dev/null || echo '{}')
-
-payload=$(jq -n \
-  --arg sessionId "$session_id" \
-  --arg cwd "$workspace_root" \
-  --argjson toolInput "$tool_input" \
-  --argjson toolResponse "$tool_response" \
-  '{
-    contentSessionId: $sessionId,
-    tool_name: "write_file",
-    tool_input: $toolInput,
-    tool_response: $toolResponse,
-    cwd: $cwd
-  }' 2>/dev/null)
-
-# Exit if payload creation failed
-if [ -z "$payload" ]; then
-  exit 0
-fi
-
-# Ensure worker is running (with retries like claude-mem hooks)
-if ! ensure_worker_running "$worker_port"; then
-  # Worker not ready - exit gracefully (don't block Cursor)
-  exit 0
-fi
-
-# Send observation to claude-mem worker (fire-and-forget)
-curl -s -X POST \
-  "http://127.0.0.1:${worker_port}/api/sessions/observations" \
-  -H "Content-Type: application/json" \
-  -d "$payload" \
-  >/dev/null 2>&1 || true
-
-exit 0
-
@@ -1,126 +0,0 @@
-# Save Observation Hook for Cursor (PowerShell)
-# Captures MCP tool usage and shell command execution
-# Maps to claude-mem's save-hook functionality
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# Source common utilities
-$commonPath = Join-Path $PSScriptRoot "common.ps1"
-if (Test-Path $commonPath) {
-    . $commonPath
-} else {
-    Write-Warning "common.ps1 not found, using fallback functions"
-    exit 0
-}
-
-# Read JSON input from stdin with error handling
-$input = Read-JsonInput
-
-# Extract common fields with safe fallbacks
-$conversationId = Get-JsonField $input "conversation_id" ""
-$generationId = Get-JsonField $input "generation_id" ""
-$workspaceRoot = Get-JsonField $input "workspace_roots[0]" ""
-
-# Fallback to current directory if no workspace root
-if (Test-IsEmpty $workspaceRoot) {
-    $workspaceRoot = Get-Location
-}
-
-# Use conversation_id as session_id (stable across turns), fallback to generation_id
-$sessionId = $conversationId
-if (Test-IsEmpty $sessionId) {
-    $sessionId = $generationId
-}
-
-# Exit if no session_id available
-if (Test-IsEmpty $sessionId) {
-    exit 0
-}
-
-# Get worker port from settings with validation
-$workerPort = Get-WorkerPort
-
-# Determine hook type and extract relevant data
-$hookEvent = Get-JsonField $input "hook_event_name" ""
-
-$payload = $null
-
-if ($hookEvent -eq "afterMCPExecution") {
-    # MCP tool execution
-    $toolName = Get-JsonField $input "tool_name" ""
-
-    if (Test-IsEmpty $toolName) {
-        exit 0
-    }
-
-    # Extract tool_input and tool_response, defaulting to {} if invalid
-    $toolInput = @{}
-    $toolResponse = @{}
-
-    if ($input.PSObject.Properties.Name -contains "tool_input") {
-        $toolInput = $input.tool_input
-        if ($null -eq $toolInput) { $toolInput = @{} }
-    }
-
-    if ($input.PSObject.Properties.Name -contains "result_json") {
-        $toolResponse = $input.result_json
-        if ($null -eq $toolResponse) { $toolResponse = @{} }
-    }
-
-    # Prepare observation payload
-    $payload = @{
-        contentSessionId = $sessionId
-        tool_name = $toolName
-        tool_input = $toolInput
-        tool_response = $toolResponse
-        cwd = $workspaceRoot
-    }
-
-} elseif ($hookEvent -eq "afterShellExecution") {
-    # Shell command execution
-    $command = Get-JsonField $input "command" ""
-
-    if (Test-IsEmpty $command) {
-        exit 0
-    }
-
-    $output = Get-JsonField $input "output" ""
-
-    # Treat shell commands as "Bash" tool usage
-    $toolInput = @{ command = $command }
-    $toolResponse = @{ output = $output }
-
-    $payload = @{
-        contentSessionId = $sessionId
-        tool_name = "Bash"
-        tool_input = $toolInput
-        tool_response = $toolResponse
-        cwd = $workspaceRoot
-    }
-
-} else {
-    exit 0
-}
-
-# Exit if payload creation failed
-if ($null -eq $payload) {
-    exit 0
-}
-
-# Ensure worker is running (with retries like claude-mem hooks)
-if (-not (Test-WorkerReady -Port $workerPort)) {
-    # Worker not ready - exit gracefully (don't block Cursor)
-    exit 0
-}
-
-# Send observation to claude-mem worker (fire-and-forget)
-$uri = "http://127.0.0.1:$workerPort/api/sessions/observations"
-
-try {
-    $bodyJson = ConvertTo-JsonCompact $payload
-    Invoke-RestMethod -Uri $uri -Method Post -Body $bodyJson -ContentType "application/json" -TimeoutSec 5 -ErrorAction SilentlyContinue | Out-Null
-} catch {
-    # Ignore errors - don't block Cursor
-}
-
-exit 0
@@ -1,129 +0,0 @@
-#!/bin/bash
-# Save Observation Hook for Cursor
-# Captures MCP tool usage and shell command execution
-# Maps to claude-mem's save-hook functionality
-
-# Source common utilities
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/common.sh" 2>/dev/null || {
-  echo "Warning: common.sh not found, using fallback functions" >&2
-}
-
-# Check dependencies (non-blocking)
-check_dependencies >/dev/null 2>&1 || true
-
-# Read JSON input from stdin with error handling
-input=$(read_json_input)
-
-# Extract common fields with safe fallbacks
-conversation_id=$(json_get "$input" "conversation_id" "")
-generation_id=$(json_get "$input" "generation_id" "")
-workspace_root=$(json_get "$input" "workspace_roots[0]" "")
-
-# Fallback to current directory if no workspace root
-if is_empty "$workspace_root"; then
-  workspace_root=$(pwd)
-fi
-
-# Use conversation_id as session_id (stable across turns), fallback to generation_id
-session_id="$conversation_id"
-if is_empty "$session_id"; then
-  session_id="$generation_id"
-fi
-
-# Exit if no session_id available
-if is_empty "$session_id"; then
-  exit 0
-fi
-
-# Get worker port from settings with validation
-worker_port=$(get_worker_port)
-
-# Determine hook type and extract relevant data
-hook_event=$(json_get "$input" "hook_event_name" "")
-
-if [ "$hook_event" = "afterMCPExecution" ]; then
-  # MCP tool execution
-  tool_name=$(json_get "$input" "tool_name" "")
-  
-  if is_empty "$tool_name"; then
-    exit 0
-  fi
-  
-  # Extract tool_input and tool_response, defaulting to {} if invalid
-  tool_input=$(echo "$input" | jq -c '.tool_input // {}' 2>/dev/null || echo "{}")
-  tool_response=$(echo "$input" | jq -c '.result_json // {}' 2>/dev/null || echo "{}")
-  
-  # Validate JSON
-  if ! echo "$tool_input" | jq empty 2>/dev/null; then
-    tool_input="{}"
-  fi
-  if ! echo "$tool_response" | jq empty 2>/dev/null; then
-    tool_response="{}"
-  fi
-  
-  # Prepare observation payload
-  payload=$(jq -n \
-    --arg sessionId "$session_id" \
-    --arg toolName "$tool_name" \
-    --argjson toolInput "$tool_input" \
-    --argjson toolResponse "$tool_response" \
-    --arg cwd "$workspace_root" \
-    '{
-      contentSessionId: $sessionId,
-      tool_name: $toolName,
-      tool_input: $toolInput,
-      tool_response: $toolResponse,
-      cwd: $cwd
-    }' 2>/dev/null)
-    
-elif [ "$hook_event" = "afterShellExecution" ]; then
-  # Shell command execution
-  command=$(json_get "$input" "command" "")
-  
-  if is_empty "$command"; then
-    exit 0
-  fi
-  
-  output=$(json_get "$input" "output" "")
-  
-  # Treat shell commands as "Bash" tool usage
-  tool_input=$(jq -n --arg cmd "$command" '{command: $cmd}' 2>/dev/null || echo '{}')
-  tool_response=$(jq -n --arg out "$output" '{output: $out}' 2>/dev/null || echo '{}')
-  
-  payload=$(jq -n \
-    --arg sessionId "$session_id" \
-    --arg cwd "$workspace_root" \
-    --argjson toolInput "$tool_input" \
-    --argjson toolResponse "$tool_response" \
-    '{
-      contentSessionId: $sessionId,
-      tool_name: "Bash",
-      tool_input: $toolInput,
-      tool_response: $toolResponse,
-      cwd: $cwd
-    }' 2>/dev/null)
-else
-  exit 0
-fi
-
-# Exit if payload creation failed
-if [ -z "$payload" ]; then
-  exit 0
-fi
-
-# Ensure worker is running (with retries like claude-mem hooks)
-if ! ensure_worker_running "$worker_port"; then
-  # Worker not ready - exit gracefully (don't block Cursor)
-  exit 0
-fi
-
-# Send observation to claude-mem worker (fire-and-forget)
-curl -s -X POST \
-  "http://127.0.0.1:${worker_port}/api/sessions/observations" \
-  -H "Content-Type: application/json" \
-  -d "$payload" \
-  >/dev/null 2>&1 || true
-
-exit 0
-
@@ -1,79 +0,0 @@
-# Session Initialization Hook for Cursor (PowerShell)
-# Maps to claude-mem's new-hook functionality
-# Initializes a new session when a prompt is submitted
-#
-# NOTE: This hook runs as part of beforeSubmitPrompt and MUST output valid JSON
-# with at least {"continue": true} to allow prompt submission.
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# Source common utilities
-$commonPath = Join-Path $PSScriptRoot "common.ps1"
-if (Test-Path $commonPath) {
-    . $commonPath
-} else {
-    # Fallback - output continue and exit
-    Write-Output '{"continue": true}'
-    exit 0
-}
-
-# Read JSON input from stdin with error handling
-$input = Read-JsonInput
-
-# Extract common fields with safe fallbacks
-$conversationId = Get-JsonField $input "conversation_id" ""
-$generationId = Get-JsonField $input "generation_id" ""
-$prompt = Get-JsonField $input "prompt" ""
-$workspaceRoot = Get-JsonField $input "workspace_roots[0]" ""
-
-# Fallback to current directory if no workspace root
-if (Test-IsEmpty $workspaceRoot) {
-    $workspaceRoot = Get-Location
-}
-
-# Get project name from workspace root
-$projectName = Get-ProjectName $workspaceRoot
-
-# Use conversation_id as session_id (stable across turns), fallback to generation_id
-$sessionId = $conversationId
-if (Test-IsEmpty $sessionId) {
-    $sessionId = $generationId
-}
-
-# Exit gracefully if no session_id available (still allow prompt)
-if (Test-IsEmpty $sessionId) {
-    Write-Output '{"continue": true}'
-    exit 0
-}
-
-# Get worker port from settings with validation
-$workerPort = Get-WorkerPort
-
-# Ensure worker is running (with retries like claude-mem hooks)
-if (-not (Test-WorkerReady -Port $workerPort)) {
-    # Worker not ready - still allow prompt to continue
-    Write-Output '{"continue": true}'
-    exit 0
-}
-
-# Strip leading slash from commands for memory agent (parity with new-hook.ts)
-# /review 101 → review 101 (more semantic for observations)
-$cleanedPrompt = $prompt
-if (-not [string]::IsNullOrEmpty($prompt) -and $prompt.StartsWith("/")) {
-    $cleanedPrompt = $prompt.Substring(1)
-}
-
-# Initialize session via HTTP - handles DB operations and privacy checks
-$payload = @{
-    contentSessionId = $sessionId
-    project = $projectName
-    prompt = $cleanedPrompt
-}
-
-# Send request to worker (fire-and-forget, don't wait for response)
-$uri = "http://127.0.0.1:$workerPort/api/sessions/init"
-Send-HttpPostAsync -Uri $uri -Body $payload
-
-# Always allow prompt to continue
-Write-Output '{"continue": true}'
-exit 0
@@ -1,93 +0,0 @@
-#!/bin/bash
-# Session Initialization Hook for Cursor
-# Maps to claude-mem's new-hook functionality
-# Initializes a new session when a prompt is submitted
-#
-# NOTE: This hook runs as part of beforeSubmitPrompt and MUST output valid JSON
-# with at least {"continue": true} to allow prompt submission.
-
-# Source common utilities
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/common.sh" 2>/dev/null || {
-  # Fallback - output continue and exit
-  echo '{"continue": true}'
-  exit 0
-}
-
-# Check dependencies (non-blocking - just warn)
-check_dependencies >/dev/null 2>&1 || true
-
-# Read JSON input from stdin with error handling
-input=$(read_json_input)
-
-# Extract common fields with safe fallbacks
-conversation_id=$(json_get "$input" "conversation_id" "")
-generation_id=$(json_get "$input" "generation_id" "")
-prompt=$(json_get "$input" "prompt" "")
-workspace_root=$(json_get "$input" "workspace_roots[0]" "")
-
-# Fallback to current directory if no workspace root
-if is_empty "$workspace_root"; then
-  workspace_root=$(pwd)
-fi
-
-# Get project name from workspace root
-project_name=$(get_project_name "$workspace_root")
-
-# Use conversation_id as session_id (stable across turns), fallback to generation_id
-session_id="$conversation_id"
-if is_empty "$session_id"; then
-  session_id="$generation_id"
-fi
-
-# Exit gracefully if no session_id available (still allow prompt)
-if is_empty "$session_id"; then
-  echo '{"continue": true}'
-  exit 0
-fi
-
-# Get worker port from settings with validation
-worker_port=$(get_worker_port)
-
-# Ensure worker is running (with retries like claude-mem hooks)
-if ! ensure_worker_running "$worker_port"; then
-  # Worker not ready - still allow prompt to continue
-  echo '{"continue": true}'
-  exit 0
-fi
-
-# Strip leading slash from commands for memory agent (parity with new-hook.ts)
-# /review 101 → review 101 (more semantic for observations)
-cleaned_prompt="$prompt"
-if [ -n "$prompt" ] && [ "${prompt:0:1}" = "/" ]; then
-  cleaned_prompt="${prompt:1}"
-fi
-
-# Initialize session via HTTP - handles DB operations and privacy checks
-payload=$(jq -n \
-  --arg sessionId "$session_id" \
-  --arg project "$project_name" \
-  --arg promptText "$cleaned_prompt" \
-  '{
-    contentSessionId: $sessionId,
-    project: $project,
-    prompt: $promptText
-  }' 2>/dev/null)
-
-# Exit if payload creation failed (still allow prompt)
-if [ -z "$payload" ]; then
-  echo '{"continue": true}'
-  exit 0
-fi
-
-# Send request to worker (fire-and-forget, don't wait for response)
-curl -s -X POST \
-  "http://127.0.0.1:${worker_port}/api/sessions/init" \
-  -H "Content-Type: application/json" \
-  -d "$payload" \
-  >/dev/null 2>&1 &
-
-# Always allow prompt to continue
-echo '{"continue": true}'
-exit 0
-
@@ -1,108 +0,0 @@
-# Session Summary Hook for Cursor (stop) - PowerShell
-# Called when agent loop ends
-#
-# This hook:
-# 1. Generates session summary
-# 2. Updates context file for next session
-#
-# Output: Empty JSON {} or {"followup_message": "..."} for auto-iteration
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# Source common utilities
-$commonPath = Join-Path $PSScriptRoot "common.ps1"
-if (Test-Path $commonPath) {
-    . $commonPath
-} else {
-    Write-Output '{}'
-    exit 0
-}
-
-# Read JSON input from stdin with error handling
-$input = Read-JsonInput
-
-# Extract common fields with safe fallbacks
-$conversationId = Get-JsonField $input "conversation_id" ""
-$generationId = Get-JsonField $input "generation_id" ""
-$workspaceRoot = Get-JsonField $input "workspace_roots[0]" ""
-$status = Get-JsonField $input "status" "completed"
-
-# Fallback workspace to current directory
-if (Test-IsEmpty $workspaceRoot) {
-    $workspaceRoot = Get-Location
-}
-
-# Get project name
-$projectName = Get-ProjectName $workspaceRoot
-
-# Use conversation_id as session_id, fallback to generation_id
-$sessionId = $conversationId
-if (Test-IsEmpty $sessionId) {
-    $sessionId = $generationId
-}
-
-# Exit if no session_id available
-if (Test-IsEmpty $sessionId) {
-    Write-Output '{}'
-    exit 0
-}
-
-# Get worker port from settings with validation
-$workerPort = Get-WorkerPort
-
-# Ensure worker is running (with retries)
-if (-not (Test-WorkerReady -Port $workerPort)) {
-    Write-Output '{}'
-    exit 0
-}
-
-# 1. Request summary generation (fire-and-forget)
-# Note: Cursor doesn't provide transcript_path like Claude Code does,
-# so we can't extract last_user_message and last_assistant_message.
-$summaryPayload = @{
-    contentSessionId = $sessionId
-    last_user_message = ""
-    last_assistant_message = ""
-}
-
-$summaryUri = "http://127.0.0.1:$workerPort/api/sessions/summarize"
-Send-HttpPostAsync -Uri $summaryUri -Body $summaryPayload
-
-# 2. Update context file for next session
-# Fetch fresh context (includes observations from this session)
-$projectEncoded = Get-UrlEncodedString $projectName
-$contextUri = "http://127.0.0.1:$workerPort/api/context/inject?project=$projectEncoded"
-$context = Get-HttpResponse -Uri $contextUri
-
-if (-not [string]::IsNullOrEmpty($context)) {
-    $rulesDir = Join-Path $workspaceRoot ".cursor\rules"
-    $rulesFile = Join-Path $rulesDir "claude-mem-context.mdc"
-
-    # Create rules directory if it doesn't exist
-    if (-not (Test-Path $rulesDir)) {
-        New-Item -ItemType Directory -Path $rulesDir -Force | Out-Null
-    }
-
-    # Write context as a Cursor rule with alwaysApply: true
-    $ruleContent = @"
---
-alwaysApply: true
-description: "Claude-mem context from past sessions (auto-updated)"
---
-
-# Memory Context from Past Sessions
-
-The following context is from claude-mem, a persistent memory system that tracks your coding sessions.
-
-$context
-
---
-*Updated after last session. Use claude-mem's MCP search tools for more detailed queries.*
-"@
-
-    Set-Content -Path $rulesFile -Value $ruleContent -Encoding UTF8 -Force
-}
-
-# Output empty JSON - no followup message
-Write-Output '{}'
-exit 0
@@ -1,111 +0,0 @@
-#!/bin/bash
-# Session Summary Hook for Cursor (stop)
-# Called when agent loop ends
-#
-# This hook:
-# 1. Generates session summary
-# 2. Updates context file for next session
-#
-# Output: Empty JSON {} or {"followup_message": "..."} for auto-iteration
-
-# Source common utilities
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/common.sh" 2>/dev/null || {
-  echo '{}'
-  exit 0
-}
-
-# Check dependencies (non-blocking)
-check_dependencies >/dev/null 2>&1 || true
-
-# Read JSON input from stdin with error handling
-input=$(read_json_input)
-
-# Extract common fields with safe fallbacks
-conversation_id=$(json_get "$input" "conversation_id" "")
-generation_id=$(json_get "$input" "generation_id" "")
-workspace_root=$(json_get "$input" "workspace_roots[0]" "")
-status=$(json_get "$input" "status" "completed")
-
-# Fallback workspace to current directory
-if is_empty "$workspace_root"; then
-  workspace_root=$(pwd)
-fi
-
-# Get project name
-project_name=$(get_project_name "$workspace_root")
-
-# Use conversation_id as session_id, fallback to generation_id
-session_id="$conversation_id"
-if is_empty "$session_id"; then
-  session_id="$generation_id"
-fi
-
-# Exit if no session_id available
-if is_empty "$session_id"; then
-  echo '{}'
-  exit 0
-fi
-
-# Get worker port from settings with validation
-worker_port=$(get_worker_port)
-
-# Ensure worker is running (with retries)
-if ! ensure_worker_running "$worker_port"; then
-  echo '{}'
-  exit 0
-fi
-
-# 1. Request summary generation (fire-and-forget)
-# Note: Cursor doesn't provide transcript_path like Claude Code does,
-# so we can't extract last_user_message and last_assistant_message.
-payload=$(jq -n \
-  --arg sessionId "$session_id" \
-  '{
-    contentSessionId: $sessionId,
-    last_user_message: "",
-    last_assistant_message: ""
-  }' 2>/dev/null)
-
-if [ -n "$payload" ]; then
-  curl -s -X POST \
-    "http://127.0.0.1:${worker_port}/api/sessions/summarize" \
-    -H "Content-Type: application/json" \
-    -d "$payload" \
-    >/dev/null 2>&1 &
-fi
-
-# 2. Update context file for next session
-# Fetch fresh context (includes observations from this session)
-project_encoded=$(url_encode "$project_name")
-context=$(curl -s -f "http://127.0.0.1:${worker_port}/api/context/inject?project=${project_encoded}" 2>/dev/null || echo "")
-
-if [ -n "$context" ]; then
-  rules_dir="${workspace_root}/.cursor/rules"
-  rules_file="${rules_dir}/claude-mem-context.mdc"
-  
-  # Create rules directory if it doesn't exist
-  mkdir -p "$rules_dir" 2>/dev/null || true
-  
-  # Write context as a Cursor rule with alwaysApply: true
-  cat > "$rules_file" 2>/dev/null << EOF
---
-alwaysApply: true
-description: "Claude-mem context from past sessions (auto-updated)"
---
-
-# Memory Context from Past Sessions
-
-The following context is from claude-mem, a persistent memory system that tracks your coding sessions.
-
-${context}
-
---
-*Updated after last session. Use claude-mem's MCP search tools for more detailed queries.*
-EOF
-fi
-
-# Output empty JSON - no followup message
-echo '{}'
-exit 0
-
@@ -1,103 +0,0 @@
-# User Message Hook for Cursor (PowerShell)
-# Displays context information to the user
-# Maps to claude-mem's user-message-hook functionality
-# Note: Cursor doesn't have a direct equivalent, but we can output to stderr
-# for visibility in Cursor's output channels
-#
-# This is an OPTIONAL hook. It can be added to beforeSubmitPrompt if desired,
-# but may be verbose since it runs on every prompt submission.
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# Read JSON input from stdin (if any)
-$inputJson = $null
-try {
-    $inputText = [Console]::In.ReadToEnd()
-    if (-not [string]::IsNullOrEmpty($inputText)) {
-        $inputJson = $inputText | ConvertFrom-Json -ErrorAction SilentlyContinue
-    }
-} catch {
-    $inputJson = $null
-}
-
-# Extract workspace root
-$workspaceRoot = ""
-if ($null -ne $inputJson -and $inputJson.PSObject.Properties.Name -contains "workspace_roots") {
-    $wsRoots = $inputJson.workspace_roots
-    if ($null -ne $wsRoots -and $wsRoots.Count -gt 0) {
-        $workspaceRoot = $wsRoots[0]
-    }
-}
-
-if ([string]::IsNullOrEmpty($workspaceRoot)) {
-    $workspaceRoot = Get-Location
-}
-
-# Get project name
-$projectName = Split-Path $workspaceRoot -Leaf
-if ([string]::IsNullOrEmpty($projectName)) {
-    $projectName = "unknown-project"
-}
-
-# Get worker port from settings
-$settingsPath = Join-Path $env:USERPROFILE ".claude-mem\settings.json"
-$workerPort = 37777
-
-if (Test-Path $settingsPath) {
-    try {
-        $settings = Get-Content $settingsPath -Raw | ConvertFrom-Json
-        if ($settings.CLAUDE_MEM_WORKER_PORT) {
-            $workerPort = [int]$settings.CLAUDE_MEM_WORKER_PORT
-        }
-    } catch {
-        # Use default
-    }
-}
-
-# Ensure worker is running
-$maxRetries = 75
-$workerReady = $false
-
-for ($i = 0; $i -lt $maxRetries; $i++) {
-    try {
-        $response = Invoke-RestMethod -Uri "http://127.0.0.1:$workerPort/api/readiness" -Method Get -TimeoutSec 1 -ErrorAction Stop
-        $workerReady = $true
-        break
-    } catch {
-        Start-Sleep -Milliseconds 200
-    }
-}
-
-# If worker not ready, exit silently
-if (-not $workerReady) {
-    exit 0
-}
-
-# Fetch formatted context from worker API (with colors)
-$projectEncoded = [System.Uri]::EscapeDataString($projectName)
-$contextUrl = "http://127.0.0.1:$workerPort/api/context/inject?project=$projectEncoded&colors=true"
-
-$output = $null
-try {
-    $output = Invoke-RestMethod -Uri $contextUrl -Method Get -TimeoutSec 5 -ErrorAction Stop
-} catch {
-    $output = $null
-}
-
-# Output to stderr for visibility (parity with user-message-hook.ts)
-# Note: Cursor may not display stderr the same way Claude Code does,
-# but this is the best we can do without direct UI integration
-if (-not [string]::IsNullOrEmpty($output)) {
-    [Console]::Error.WriteLine("")
-    [Console]::Error.WriteLine("📝 Claude-Mem Context Loaded")
-    [Console]::Error.WriteLine("   ℹ️  Viewing context from past sessions")
-    [Console]::Error.WriteLine("")
-    [Console]::Error.WriteLine($output)
-    [Console]::Error.WriteLine("")
-    [Console]::Error.WriteLine("💡 Tip: Wrap content with <private> ... </private> to prevent storing sensitive information.")
-    [Console]::Error.WriteLine("💬 Community: https://discord.gg/J4wttp9vDu")
-    [Console]::Error.WriteLine("📺 Web Viewer: http://localhost:$workerPort/")
-    [Console]::Error.WriteLine("")
-}
-
-exit 0
@@ -1,70 +0,0 @@
-#!/bin/bash
-# User Message Hook for Cursor
-# Displays context information to the user
-# Maps to claude-mem's user-message-hook functionality
-# Note: Cursor doesn't have a direct equivalent, but we can output to stderr
-# for visibility in Cursor's output channels
-#
-# This is an OPTIONAL hook. It can be added to beforeSubmitPrompt if desired,
-# but may be verbose since it runs on every prompt submission.
-
-# Read JSON input from stdin (if any)
-input=$(cat 2>/dev/null || echo "{}")
-
-# Extract workspace root
-workspace_root=$(echo "$input" | jq -r '.workspace_roots[0] // empty' 2>/dev/null || echo "")
-
-if [ -z "$workspace_root" ]; then
-  workspace_root=$(pwd)
-fi
-
-# Get project name
-project_name=$(basename "$workspace_root" 2>/dev/null || echo "unknown-project")
-
-# Get worker port from settings
-data_dir="${HOME}/.claude-mem"
-settings_file="${data_dir}/settings.json"
-worker_port="37777"
-
-if [ -f "$settings_file" ]; then
-  worker_port=$(jq -r '.CLAUDE_MEM_WORKER_PORT // "37777"' "$settings_file" 2>/dev/null || echo "37777")
-fi
-
-# Ensure worker is running
-max_retries=75
-retry_count=0
-while [ $retry_count -lt $max_retries ]; do
-  if curl -s -f "http://127.0.0.1:${worker_port}/api/readiness" > /dev/null 2>&1; then
-    break
-  fi
-  sleep 0.2
-  retry_count=$((retry_count + 1))
-done
-
-# If worker not ready, exit silently
-if [ $retry_count -eq $max_retries ]; then
-  exit 0
-fi
-
-# Fetch formatted context from worker API (with colors)
-context_url="http://127.0.0.1:${worker_port}/api/context/inject?project=${project_name}&colors=true"
-output=$(curl -s -f "$context_url" 2>/dev/null || echo "")
-
-# Output to stderr for visibility (parity with user-message-hook.ts)
-# Note: Cursor may not display stderr the same way Claude Code does,
-# but this is the best we can do without direct UI integration
-if [ -n "$output" ]; then
-  echo "" >&2
-  echo "📝 Claude-Mem Context Loaded" >&2
-  echo "   ℹ️  Viewing context from past sessions" >&2
-  echo "" >&2
-  echo "$output" >&2
-  echo "" >&2
-  echo "💡 Tip: Wrap content with <private> ... </private> to prevent storing sensitive information." >&2
-  echo "💬 Community: https://discord.gg/J4wttp9vDu" >&2
-  echo "📺 Web Viewer: http://localhost:${worker_port}/" >&2
-  echo "" >&2
-fi
-
-exit 0
-
@@ -0,0 +1,83 @@
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Nov 6, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4241 | 11:19 PM | 🟣 | Object-Oriented Architecture Design Document Created | ~662 |
+| #4240 | 11:11 PM | 🟣 | Worker Service Rewrite Blueprint Created | ~541 |
+| #4239 | 11:07 PM | 🟣 | Comprehensive Worker Service Performance Analysis Document Created | ~541 |
+| #4238 | 10:59 PM | 🔵 | Overhead Analysis Document Checked | ~203 |
+
+### Nov 7, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #4609 | 6:33 PM | ✅ | PR #69 Successfully Merged to Main Branch | ~516 |
+| #4600 | 6:31 PM | 🟣 | Added Worker Service Documentation Suite | ~441 |
+| #4597 | " | 🔄 | Worker Service Refactored to Object-Oriented Architecture | ~473 |
+
+### Nov 8, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #5539 | 10:20 PM | 🔵 | Harsh critical audit of context-hook reveals systematic anti-patterns | ~3154 |
+| #5497 | 9:29 PM | 🔵 | Harsh critical audit of context-hook reveals systematic anti-patterns | ~2815 |
+| #5495 | 9:28 PM | 🔵 | Context Hook Audit Reveals Project Anti-Patterns | ~660 |
+| #5476 | 9:17 PM | 🔵 | Critical Code Audit Identified 14 Anti-Patterns in Context Hook | ~887 |
+| #5391 | 8:45 PM | 🔵 | Critical Code Quality Audit of Context Hook Implementation | ~720 |
+| #5150 | 7:37 PM | 🟣 | Troubleshooting Skill Added to Claude-Mem Plugin | ~427 |
+
+### Nov 9, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #6161 | 11:55 PM | 🔵 | YC W26 Application Research and Preparation Completed for Claude-Mem | ~1628 |
+| #6155 | 11:47 PM | ✅ | Comprehensive Y Combinator Winter 2026 Application Notes Created | ~1045 |
+| #5979 | 7:58 PM | 🔵 | Smart Contextualization Feature Architecture | ~560 |
+| #5971 | 7:49 PM | 🔵 | Hooks Reference Documentation Structure | ~448 |
+| #5929 | 7:08 PM | ✅ | Documentation Updates for v5.4.0 Skill-Based Search Migration | ~604 |
+| #5927 | " | ✅ | Updated Configuration Documentation for Skill-Based Search | ~497 |
+| #5920 | 7:05 PM | ✅ | Renamed Architecture Documentation File Reference | ~271 |
+
+### Nov 18, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #11515 | 8:22 PM | 🔵 | Smart Contextualization Architecture Retrieved with Command Hook Pattern Details | ~502 |
+
+### Dec 8, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #22294 | 9:43 PM | 🔵 | Documentation Site Structure Located | ~359 |
+
+### Dec 12, 2025
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #24430 | 8:27 PM | ✅ | Removed Final Platform Check Reference from Linux Section | ~320 |
+| #24429 | " | ✅ | Final Platform Check Reference Removal from Linux Section | ~274 |
+| #24428 | " | ✅ | Corrected Second Line Number Reference for Migration Marker Logic | ~267 |
+| #24427 | 8:26 PM | ✅ | Updated Line Number Reference for PM2 Cleanup Implementation | ~260 |
+| #24426 | " | ✅ | Removed Platform Check from Manual Marker Deletion Scenario | ~338 |
+| #24425 | " | ✅ | Removed Platform Check from Fresh Install Scenario Flow | ~314 |
+| #24424 | 8:25 PM | ✅ | Renumbered Manual Marker Deletion Scenario | ~285 |
+| #24423 | " | ✅ | Renumbered Fresh Install Scenario | ~243 |
+| #24422 | " | ✅ | Removed Obsolete Windows Platform Detection Scenario | ~311 |
+| #24421 | " | ✅ | Removed Platform Check from macOS Migration Documentation | ~294 |
+| #24420 | 8:24 PM | ✅ | Platform Check Removed from Migration Documentation | ~288 |
+| #24417 | 8:16 PM | ✅ | Code Reference Example Updated to Reflect Actual Cross-Platform Implementation | ~366 |
+| #24416 | " | ✅ | Architecture Decision Documentation Updated to Reflect Cross-Platform PM2 Cleanup Rationale | ~442 |
+| #24415 | 8:15 PM | ✅ | Migration Marker Lifecycle Documentation Updated for Unified Cross-Platform Behavior | ~463 |
+| #24414 | " | ✅ | Platform Comparison Table Updated to Reflect Unified Cross-Platform Migration | ~351 |
+| #24413 | " | ✅ | Windows Platform-Specific Documentation Completely Rewritten for Unified Migration | ~428 |
+| #24412 | " | ✅ | User Experience Timeline Updated for Cross-Platform PM2 Cleanup | ~291 |
+| #24411 | 8:14 PM | ✅ | Migration Marker Lifecycle Documentation Updated for All Platforms | ~277 |
+| #24410 | " | ✅ | Marker File Platform Behavior Documentation Updated for Unified Migration | ~282 |
+| #24409 | " | ✅ | Migration Steps Documentation Updated for Cross-Platform PM2 Cleanup | ~278 |
+| #24408 | 8:13 PM | ✅ | PM2 Migration Documentation Updated to Remove Windows Platform Check | ~280 |
+</claude-mem-context>
@@ -0,0 +1,213 @@
+# Claude-Mem PR Shipping Report
+*Generated: 2026-02-04*
+
+## Executive Summary
+
+6 PRs analyzed for shipping readiness. **1 is ready to merge**, 4 have conflicts, 1 is too large for easy review.
+
+| PR | Title | Status | Recommendation |
+|----|-------|--------|----------------|
+| **#856** | Idle timeout for zombie processes | ✅ **MERGEABLE** | **Ship it** |
+| #700 | Windows Terminal popup fix | ⚠️ Conflicts | Rebase, then ship |
+| #722 | In-process worker architecture | ⚠️ Conflicts | Rebase, high impact |
+| #657 | generate/clean CLI commands | ⚠️ Conflicts | Rebase, then ship |
+| #863 | Ragtime email investigation | 🔍 Needs review | Research pending |
+| #464 | Sleep Agent Pipeline (contributor) | 🔴 Too large | Request split or dedicated review |
+
+---
+
+## Ready to Ship
+
+### PR #856: Idle Timeout for Zombie Observer Processes
+**Status:** ✅ MERGEABLE (no conflicts)
+
+| Metric | Value |
+|--------|-------|
+| Additions | 928 |
+| Deletions | 171 |
+| Files | 8 |
+| Risk | Low-Medium |
+
+**What it does:**
+- Adds 3-minute idle timeout to `SessionQueueProcessor`
+- Prevents zombie observer processes that were causing 13.4GB swap usage
+- Processes exit gracefully after inactivity instead of waiting forever
+
+**Why ship it:**
+- Fixes real user-reported issue (79 zombie processes)
+- Well-tested (11 new tests, 440 lines of test coverage)
+- Clean implementation, preventive approach
+- Supersedes PR #848's reactive cleanup
+- No conflicts, ready to merge
+
+**Review notes:**
+- 1 Greptile bot comment (addressed)
+- Race condition fix included
+- Enhanced logging added
+
+---
+
+## Needs Rebase (Have Conflicts)
+
+### PR #700: Windows Terminal Popup Fix
+**Status:** ⚠️ CONFLICTING
+
+| Metric | Value |
+|--------|-------|
+| Additions | 187 |
+| Deletions | 399 |
+| Files | 8 |
+| Risk | Medium |
+
+**What it does:**
+- Eliminates Windows Terminal popup by removing spawn-based daemon
+- Worker `start` command becomes daemon directly (no child spawn)
+- Removes `restart` command (users do `stop` then `start`)
+- Net simplification: -212 lines
+
+**Breaking changes:**
+- `restart` command removed
+
+**Review status:**
+- ✅ 1 APPROVAL from @volkanfirat (Jan 15, 2026)
+
+**Action needed:** Resolve conflicts, then ready to ship.
+
+---
+
+### PR #722: In-Process Worker Architecture
+**Status:** ⚠️ CONFLICTING
+
+| Metric | Value |
+|--------|-------|
+| Additions | 869 |
+| Deletions | 4,658 |
+| Files | 112 |
+| Risk | High |
+
+**What it does:**
+- Hook processes become the worker (no separate daemon spawning)
+- First hook that needs worker becomes the worker
+- Eliminates Windows spawn issues ("NO SPAWN" rule)
+- 761 tests pass
+
+**Architectural impact:** HIGH
+- Fundamentally changes worker lifecycle
+- Hook processes stay alive (they ARE the worker)
+- First hook wins port 37777, others use HTTP
+
+**Action needed:** Resolve conflicts. Consider relationship with PR #700 (both touch worker architecture).
+
+---
+
+### PR #657: Generate/Clean CLI Commands
+**Status:** ⚠️ CONFLICTING
+
+| Metric | Value |
+|--------|-------|
+| Additions | 1,184 |
+| Deletions | 5,057 |
+| Files | 104 |
+| Risk | Medium |
+
+**What it does:**
+- Adds `claude-mem generate` and `claude-mem clean` CLI commands
+- Fixes validation bugs (deleted folders recreated from stale DB)
+- Fixes Windows path handling
+- Adds automatic shell alias installation
+- Disables subdirectory CLAUDE.md files by default
+
+**Breaking changes:**
+- Default behavior change: folder CLAUDE.md now disabled by default
+
+**Action needed:** Resolve conflicts, complete Windows testing.
+
+---
+
+## Needs Attention
+
+### PR #863: Ragtime Email Investigation
+**Status:** 🔍 Research pending
+
+Research agent did not return results. Manual review needed.
+
+---
+
+### PR #464: Sleep Agent Pipeline (Contributor: @laihenyi)
+**Status:** 🔴 Too large for effective review
+
+| Metric | Value |
+|--------|-------|
+| Additions | 15,430 |
+| Deletions | 469 |
+| Files | 73 |
+| Wait time | 37+ days |
+| Risk | High |
+
+**What it does:**
+- Sleep Agent Pipeline with memory tiering
+- Supersession detection
+- Session Statistics API (`/api/session/:id/stats`)
+- StatusLine + PreCompact hooks
+- Context Generator improvements
+- Self-healing CI workflow
+
+**Concerns:**
+| Issue | Details |
+|-------|---------|
+| 🔴 Size | 15K+ lines is too large for effective review |
+| 🔴 SupersessionDetector | Single file with 1,282 additions |
+| 🟡 No tests visible | Test plan checkboxes unchecked |
+| 🟡 Self-healing CI | Auto-fix workflow could cause infinite commit loops |
+| 🟡 Serena config | Adds `.serena/` tooling |
+
+**Recommendation:**
+1. **Option A:** Request contributor split into 4-5 smaller PRs
+2. **Option B:** Allocate dedicated review time (several hours)
+3. **Option C:** Cherry-pick specific features (hooks, stats API)
+
+**Note:** Contributor has been waiting 37+ days. Deserves response either way.
+
+---
+
+## Shipping Strategy
+
+### Phase 1: Quick Wins (This Week)
+1. **Merge #856** — Ready now, fixes real user issue
+2. **Rebase #700** — Has approval, Windows fix needed
+3. **Rebase #657** — Useful CLI commands
+
+### Phase 2: Architecture (Careful Review)
+4. **Review #722** — High impact, conflicts with #700 approach?
+   - Both PRs eliminate spawning but in different ways
+   - May need to pick one approach
+
+### Phase 3: Contributor PR
+5. **Respond to #464** — Options:
+   - Ask for split
+   - Schedule dedicated review
+   - Cherry-pick subset
+
+### Phase 4: Investigation
+6. **Manual review #863** — Ragtime email feature
+
+---
+
+## Conflict Resolution Order
+
+Since multiple PRs have conflicts, suggested rebase order:
+
+1. **#856** (merge first — no conflicts)
+2. **#700** (rebase onto main after #856)
+3. **#657** (rebase onto main after #700)
+4. **#722** (rebase last — may conflict with #700 architecturally)
+
+---
+
+## Summary
+
+| Ready | Conflicts | Needs Work |
+|-------|-----------|------------|
+| 1 PR (#856) | 3 PRs (#700, #722, #657) | 2 PRs (#464, #863) |
+
+**Immediate action:** Merge #856, then rebase the conflict PRs in order.
@@ -0,0 +1,79 @@
+# Version Consistency Fix (Issue #XXX)
+
+## Problem
+Version mismatch between plugin and worker caused infinite restart loop:
+- Plugin version: 9.0.0 (from plugin/.claude-plugin/plugin.json)
+- Worker binary version: 8.5.9 (hardcoded in bundled worker-service.cjs)
+
+This triggered the auto-restart mechanism on every hook call, which killed the SDK generator before it could complete the Claude API call to generate observations. Result: 0 observations were ever saved to the database despite hooks firing successfully.
+
+## Root Cause
+The `plugin/package.json` file had version `8.5.10` instead of `9.0.0`. When the project was last built, the build script correctly injected the version from root `package.json` into the bundled worker service. However, the `plugin/package.json` was manually created/edited and fell out of sync.
+
+At runtime:
+1. Worker service reads version from `~/.claude/plugins/marketplaces/thedotmack/package.json` → gets `8.5.10`
+2. Running worker returns built-in version via `/api/version` → returns `8.5.9` (from old build)
+3. Version check in `worker-service.ts` start command detects mismatch
+4. Auto-restart triggered on every hook call
+5. Observations never saved
+
+## Solution
+1. Updated `plugin/package.json` from version `8.5.10` to `9.0.0`
+2. Rebuilt all hooks and worker service to inject correct version (`9.0.0`) into bundled artifacts
+3. Added comprehensive test suite to prevent future version mismatches
+
+## Verification
+All versions now match:
+```
+Root package.json:       9.0.0 ✓
+plugin/package.json:     9.0.0 ✓
+plugin.json:             9.0.0 ✓
+marketplace.json:        9.0.0 ✓
+worker-service.cjs:      9.0.0 ✓
+```
+
+## Prevention
+To prevent this issue in the future:
+
+1. **Automated Build Process**: The `scripts/build-hooks.js` now regenerates `plugin/package.json` automatically with the correct version from root `package.json`
+
+2. **Version Consistency Tests**: Added `tests/infrastructure/version-consistency.test.ts` to verify all version sources match
+
+3. **Version Management Best Practices**:
+   - NEVER manually edit `plugin/package.json` - it's auto-generated during build
+   - Always update version in root `package.json` only
+   - Run `npm run build` after version changes
+   - The build script will sync the version to all necessary locations
+
+## Files Changed
+- `plugin/package.json` - Updated version from 8.5.10 to 9.0.0
+- `plugin/scripts/worker-service.cjs` - Rebuilt with version 9.0.0 injected
+- `plugin/scripts/mcp-server.cjs` - Rebuilt with version 9.0.0 injected
+- `plugin/scripts/*.js` (hooks) - Rebuilt with version 9.0.0 injected
+- `tests/infrastructure/version-consistency.test.ts` - New test suite
+
+## Testing
+Run the version consistency test:
+```bash
+npm run test:infra
+```
+
+Or manually verify:
+```bash
+node -e "
+const fs = require('fs');
+const rootPkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+const pluginPkg = JSON.parse(fs.readFileSync('plugin/package.json', 'utf-8'));
+const workerContent = fs.readFileSync('plugin/scripts/worker-service.cjs', 'utf-8');
+const workerMatch = workerContent.match(/Bre=\"([0-9.]+)\"/);
+console.log('Root:', rootPkg.version);
+console.log('Plugin:', pluginPkg.version);
+console.log('Worker:', workerMatch ? workerMatch[1] : 'NOT_FOUND');
+"
+```
+
+## Related Code Locations
+- **Version Injection**: `scripts/build-hooks.js` line 43-45, 105, 130, 155, 178
+- **Version Check**: `src/services/infrastructure/HealthMonitor.ts` line 133-143
+- **Auto-Restart Logic**: `src/services/worker-service.ts` line 627-645
+- **Runtime Version Read**: `src/shared/worker-utils.ts` line 73-76, 82-91
@@ -0,0 +1,338 @@
+# Get started with Claude Code hooks
+
+> Learn how to customize and extend Claude Code's behavior by registering shell commands
+
+Claude Code hooks are user-defined shell commands that execute at various points
+in Claude Code's lifecycle. Hooks provide deterministic control over Claude
+Code's behavior, ensuring certain actions always happen rather than relying on
+the LLM to choose to run them.
+
+<Tip>
+  For reference documentation on hooks, see [Hooks reference](/en/hooks).
+</Tip>
+
+Example use cases for hooks include:
+
+* **Notifications**: Customize how you get notified when Claude Code is awaiting
+  your input or permission to run something.
+* **Automatic formatting**: Run `prettier` on .ts files, `gofmt` on .go files,
+  etc. after every file edit.
+* **Logging**: Track and count all executed commands for compliance or
+  debugging.
+* **Feedback**: Provide automated feedback when Claude Code produces code that
+  does not follow your codebase conventions.
+* **Custom permissions**: Block modifications to production files or sensitive
+  directories.
+
+By encoding these rules as hooks rather than prompting instructions, you turn
+suggestions into app-level code that executes every time it is expected to run.
+
+<Warning>
+  You must consider the security implication of hooks as you add them, because hooks run automatically during the agent loop with your current environment's credentials.
+  For example, malicious hooks code can exfiltrate your data. Always review your hooks implementation before registering them.
+
+  For full security best practices, see [Security Considerations](/en/hooks#security-considerations) in the hooks reference documentation.
+</Warning>
+
+## Hook Events Overview
+
+Claude Code provides several hook events that run at different points in the
+workflow:
+
+* **PreToolUse**: Runs before tool calls (can block them)
+* **PermissionRequest**: Runs when a permission dialog is shown (can allow or deny)
+* **PostToolUse**: Runs after tool calls complete
+* **UserPromptSubmit**: Runs when the user submits a prompt, before Claude processes it
+* **Notification**: Runs when Claude Code sends notifications
+* **Stop**: Runs when Claude Code finishes responding
+* **SubagentStop**: Runs when subagent tasks complete
+* **PreCompact**: Runs before Claude Code is about to run a compact operation
+* **SessionStart**: Runs when Claude Code starts a new session or resumes an existing session
+* **SessionEnd**: Runs when Claude Code session ends
+
+Each event receives different data and can control Claude's behavior in
+different ways.
+
+## Quickstart
+
+In this quickstart, you'll add a hook that logs the shell commands that Claude
+Code runs.
+
+### Prerequisites
+
+Install `jq` for JSON processing in the command line.
+
+### Step 1: Open hooks configuration
+
+Run the `/hooks` [slash command](/en/slash-commands) and select
+the `PreToolUse` hook event.
+
+`PreToolUse` hooks run before tool calls and can block them while providing
+Claude feedback on what to do differently.
+
+### Step 2: Add a matcher
+
+Select `+ Add new matcher…` to run your hook only on Bash tool calls.
+
+Type `Bash` for the matcher.
+
+<Note>You can use `*` to match all tools.</Note>
+
+### Step 3: Add the hook
+
+Select `+ Add new hook…` and enter this command:
+
+```bash  theme={null}
+jq -r '"\(.tool_input.command) - \(.tool_input.description // "No description")"' >> ~/.claude/bash-command-log.txt
+```
+
+### Step 4: Save your configuration
+
+For storage location, select `User settings` since you're logging to your home
+directory. This hook will then apply to all projects, not just your current
+project.
+
+Then press `Esc` until you return to the REPL. Your hook is now registered.
+
+### Step 5: Verify your hook
+
+Run `/hooks` again or check `~/.claude/settings.json` to see your configuration:
+
+```json  theme={null}
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "jq -r '\"\\(.tool_input.command) - \\(.tool_input.description // \"No description\")\"' >> ~/.claude/bash-command-log.txt"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### Step 6: Test your hook
+
+Ask Claude to run a simple command like `ls` and check your log file:
+
+```bash  theme={null}
+cat ~/.claude/bash-command-log.txt
+```
+
+You should see entries like:
+
+```
+ls - Lists files and directories
+```
+
+## More Examples
+
+<Note>
+  For a complete example implementation, see the [bash command validator example](https://github.com/anthropics/claude-code/blob/main/examples/hooks/bash_command_validator_example.py) in our public codebase.
+</Note>
+
+### Code Formatting Hook
+
+Automatically format TypeScript files after editing:
+
+```json  theme={null}
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.ts$'; then npx prettier --write \"$file_path\"; fi; }"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### Markdown Formatting Hook
+
+Automatically fix missing language tags and formatting issues in markdown files:
+
+```json  theme={null}
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/markdown_formatter.py"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Create `.claude/hooks/markdown_formatter.py` with this content:
+
+````python  theme={null}
+#!/usr/bin/env python3
+"""
+Markdown formatter for Claude Code output.
+Fixes missing language tags and spacing issues while preserving code content.
+"""
+import json
+import sys
+import re
+import os
+
+def detect_language(code):
+    """Best-effort language detection from code content."""
+    s = code.strip()
+    
+    # JSON detection
+    if re.search(r'^\s*[{\[]', s):
+        try:
+            json.loads(s)
+            return 'json'
+        except:
+            pass
+    
+    # Python detection
+    if re.search(r'^\s*def\s+\w+\s*\(', s, re.M) or \
+       re.search(r'^\s*(import|from)\s+\w+', s, re.M):
+        return 'python'
+    
+    # JavaScript detection  
+    if re.search(r'\b(function\s+\w+\s*\(|const\s+\w+\s*=)', s) or \
+       re.search(r'=>|console\.(log|error)', s):
+        return 'javascript'
+    
+    # Bash detection
+    if re.search(r'^#!.*\b(bash|sh)\b', s, re.M) or \
+       re.search(r'\b(if|then|fi|for|in|do|done)\b', s):
+        return 'bash'
+    
+    # SQL detection
+    if re.search(r'\b(SELECT|INSERT|UPDATE|DELETE|CREATE)\s+', s, re.I):
+        return 'sql'
+        
+    return 'text'
+
+def format_markdown(content):
+    """Format markdown content with language detection."""
+    # Fix unlabeled code fences
+    def add_lang_to_fence(match):
+        indent, info, body, closing = match.groups()
+        if not info.strip():
+            lang = detect_language(body)
+            return f"{indent}```{lang}\n{body}{closing}\n"
+        return match.group(0)
+    
+    fence_pattern = r'(?ms)^([ \t]{0,3})```([^\n]*)\n(.*?)(\n\1```)\s*$'
+    content = re.sub(fence_pattern, add_lang_to_fence, content)
+    
+    # Fix excessive blank lines (only outside code fences)
+    content = re.sub(r'\n{3,}', '\n\n', content)
+    
+    return content.rstrip() + '\n'
+
+# Main execution
+try:
+    input_data = json.load(sys.stdin)
+    file_path = input_data.get('tool_input', {}).get('file_path', '')
+    
+    if not file_path.endswith(('.md', '.mdx')):
+        sys.exit(0)  # Not a markdown file
+    
+    if os.path.exists(file_path):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        formatted = format_markdown(content)
+        
+        if formatted != content:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(formatted)
+            print(f"✓ Fixed markdown formatting in {file_path}")
+    
+except Exception as e:
+    print(f"Error formatting markdown: {e}", file=sys.stderr)
+    sys.exit(1)
+````
+
+Make the script executable:
+
+```bash  theme={null}
+chmod +x .claude/hooks/markdown_formatter.py
+```
+
+This hook automatically:
+
+* Detects programming languages in unlabeled code blocks
+* Adds appropriate language tags for syntax highlighting
+* Fixes excessive blank lines while preserving code content
+* Only processes markdown files (`.md`, `.mdx`)
+
+### Custom Notification Hook
+
+Get desktop notifications when Claude needs input:
+
+```json  theme={null}
+{
+  "hooks": {
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "notify-send 'Claude Code' 'Awaiting your input'"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### File Protection Hook
+
+Block edits to sensitive files:
+
+```json  theme={null}
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 -c \"import json, sys; data=json.load(sys.stdin); path=data.get('tool_input',{}).get('file_path',''); sys.exit(2 if any(p in path for p in ['.env', 'package-lock.json', '.git/']) else 0)\""
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Learn more
+
+* For reference documentation on hooks, see [Hooks reference](/en/hooks).
+* For comprehensive security best practices and safety guidelines, see [Security Considerations](/en/hooks#security-considerations) in the hooks reference documentation.
+* For troubleshooting steps and debugging techniques, see [Debugging](/en/hooks#debugging) in the hooks reference
+  documentation.
+
+
+---
+
+> To find navigation and other pages in this documentation, fetch the llms.txt file at: https://code.claude.com/docs/llms.txt
@@ -1,5 +1,4 @@
-🌐 هذه ترجمة آلية. نرحب بالتصحيحات من المجتمع!
-
+<section dir="rtl">
 <h1 align="center">
  <br>
  <a href="https://github.com/thedotmack/claude-mem">
@@ -14,6 +13,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +33,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -43,7 +44,8 @@
  <a href="README.no.md">🇳🇴 Norsk</a>
 </p>

-<h4 align="center">نظام ضغط الذاكرة المستمرة المبني لـ <a href="https://claude.com/claude-code" target="_blank">Claude Code</a>.</h4>
+<h4 align="center">أداة إضافية لـ <a href="https://claude.com/claude-code" target="_blank">Claude Code</a> تعمل على أتمتة تسجيل معلومات الجلسات السابقه، وضغطها, ثم حقن السياق ذي الصلة في الجلسات المستقبلية.
+</h4>

 <p align="center">
  <a href="LICENSE">
@@ -80,25 +82,27 @@
  </a>
 </p>

-<p align="center">
-  <a href="#البدء-السريع">البدء السريع</a> •
-  <a href="#كيف-يعمل">كيف يعمل</a> •
-  <a href="#أدوات-البحث-mcp">أدوات البحث</a> •
-  <a href="#التوثيق">التوثيق</a> •
-  <a href="#الإعدادات">الإعدادات</a> •
-  <a href="#استكشاف-الأخطاء-وإصلاحها">استكشاف الأخطاء وإصلاحها</a> •
-  <a href="#الترخيص">الترخيص</a>
-</p>

 <p align="center">
-  يحافظ Claude-Mem بسلاسة على السياق عبر الجلسات من خلال التقاط الملاحظات حول استخدام الأدوات تلقائيًا، وإنشاء ملخصات دلالية، وإتاحتها للجلسات المستقبلية. هذا يمكّن Claude من الحفاظ على استمرارية المعرفة حول المشاريع حتى بعد انتهاء الجلسات أو إعادة الاتصال.
+  <a href="#بداية-سريعة">بداية سريعة</a> •
+  <a href="#كيف-يعمل">كيف يعمل</a> •
+  <a href="#أدوات-البحث-mcp-search-tools">أدوات البحث</a> •
+  <a href="#المستندات">التوثيق</a> •
+  <a href="#الإعدادات">الإعدادات</a> •
+  <a href="#استكشاف-الأخطاء-وإصلاحها">استكشاف الأخطاء وإصلاحها</a> •
+  <a href="#الترخيص-license">الترخيص</a>
+</p>
+
+<p align="center"  dir="rtl">
+Claude-Mem هو نظام متطور مصمم لضغط وحفظ الذاكرة لسياق عمل Claude Code. وظيفته الأساسية هي جعل "كلود" يتذكر ما فعله في جلسات العمل السابقة بسلاسة، عبر تسجيل تحركاته، وإنشاء ملخصات ذكية، واستدعائها في الجلسات المستقبلية. هذا يضمن عدم ضياع سياق المشروع حتى لو أغلقت البرنامج وفتحته لاحقاً.
 </p>

 ---

-## البدء السريع
+## بداية سريعة 

-ابدأ جلسة Claude Code جديدة في الطرفية وأدخل الأوامر التالية:
+للبدء، افتح "Claude Code" في مبنى الأوامر (Terminal) واكتب الأوامر التالية:
+<div dir="ltr"  align="left">

 ```
 > /plugin marketplace add thedotmack/claude-mem
@@ -106,32 +110,34 @@
 > /plugin install claude-mem
 ```

-أعد تشغيل Claude Code. سيظهر السياق من الجلسات السابقة تلقائيًا في الجلسات الجديدة.
+</div>
+
+بمجرد إعادة تشغيل Claude Code، سيتم استدعاء السياق من الجلسات السابقة تلقائيا عند الحاجة.

 **الميزات الرئيسية:**

- 🧠 **ذاكرة مستمرة** - يبقى السياق عبر الجلسات
- 📊 **الكشف التدريجي** - استرجاع الذاكرة بطبقات مع رؤية تكلفة الرموز
- 🔍 **بحث قائم على المهارات** - استعلم عن تاريخ مشروعك باستخدام مهارة mem-search
- 🖥️ **واجهة مستخدم ويب** - بث الذاكرة المباشر على http://localhost:37777
- 💻 **مهارة Claude Desktop** - ابحث في الذاكرة من محادثات Claude Desktop
- 🔒 **التحكم في الخصوصية** - استخدم وسوم `<private>` لاستبعاد المحتوى الحساس من التخزين
- ⚙️ **إعدادات السياق** - تحكم دقيق في السياق الذي يتم حقنه
- 🤖 **تشغيل تلقائي** - لا يتطلب تدخلاً يدويًا
- 🔗 **الاستشهادات** - رجوع إلى الملاحظات السابقة باستخدام المعرفات (الوصول عبر http://localhost:37777/api/observation/{id} أو عرض الكل في عارض الويب على http://localhost:37777)
- 🧪 **قناة تجريبية** - جرّب الميزات التجريبية مثل Endless Mode عبر تبديل الإصدار
+- 🧠 **ذاكرة مستديمه**:  سياق عملك لا ينتهي بانتهاء الجلسة، بل ينتقل معك للجلسة التالية.
+- 📊 **الكشف التدريجي** (Progressive Disclosure): نظام ذكي يستدعي المعلومات على طبقات، مما يمنحك رؤية واضحة لاستهلاك الـ "Tokens" (التكلفة).
+- 🔍 **بحث سريع** - استعلم عن سجل مشروعك باستخدام خاصية `mem-search`.
+- 🖥️ **واجهة مستخدم ويب** - رؤية معلومات الذاكرة مع  تحديث فوري عبر المتصفح من خلال الرابط: http://localhost:37777
+- 💻 **تكامل مع Claude Desktop** - إمكانية البحث في الذاكرة مباشرة من واجهة Claude المكتبية
+- 🔒 **التحكم في الخصوصية** - دعم وسم `<private>` لمنع النظام من تخزين أي معلومات حساسة.
+- ⚙️ **إعدادات السياق** - تحكم دقيق في السياق (context) التي سيتم حقنها في سياق المحادثة.
+- 🤖 **أتمتة كاملة:** - النظام يعمل في الخلفية دون الحاجة لتدخل يدوي منك.
+- 🔗 **الاستشهادات** - رجوع إلى الملاحظات السابقة باستخدام (http://localhost:37777/api/observation/{id} أو عرض جميع المعلومات على http://localhost:37777)
+- 🧪 **مزايا التجريبيه** - تجربة مميزات مثل "الوضع اللانهائي" (Endless Mode).

 ---

-## التوثيق
+## المستندات 

-📚 **[عرض التوثيق الكامل](docs/)** - تصفح مستندات markdown على GitHub
+📚 **[عرض التوثيق الكامل](https://docs.claude-mem.ai/)** - تصفح على الموقع الرسمي

 ### البدء

 - **[دليل التثبيت](https://docs.claude-mem.ai/installation)** - البدء السريع والتثبيت المتقدم
 - **[دليل الاستخدام](https://docs.claude-mem.ai/usage/getting-started)** - كيف يعمل Claude-Mem تلقائيًا
- **[أدوات البحث](https://docs.claude-mem.ai/usage/search-tools)** - استعلم عن تاريخ مشروعك باللغة الطبيعية
+- **[أدوات البحث](https://docs.claude-mem.ai/usage/search-tools)** - استعلم عن سجل مشروعك بلغتك
 - **[الميزات التجريبية](https://docs.claude-mem.ai/beta-features)** - جرّب الميزات التجريبية مثل Endless Mode

 ### أفضل الممارسات
@@ -142,9 +148,9 @@
 ### البنية المعمارية

 - **[نظرة عامة](https://docs.claude-mem.ai/architecture/overview)** - مكونات النظام وتدفق البيانات
- **[تطور البنية المعمارية](https://docs.claude-mem.ai/architecture-evolution)** - الرحلة من v3 إلى v5
- **[بنية الخطافات](https://docs.claude-mem.ai/hooks-architecture)** - كيف يستخدم Claude-Mem خطافات دورة الحياة
- **[مرجع الخطافات](https://docs.claude-mem.ai/architecture/hooks)** - شرح 7 سكريبتات خطافات
+- **[تطور البنية المعمارية](https://docs.claude-mem.ai/architecture-evolution)** - تطور المعمارية من v3 إلى v5
+- **[بنية برامج الربط (Hooks)](https://docs.claude-mem.ai/hooks-architecture)** - كيف يستخدم Claude-Mem خطافات دورة الحياة
+- **[مرجع برامج الربط (Hooks)](https://docs.claude-mem.ai/architecture/hooks)** - شرح 7 سكريبتات خطافات
 - **[خدمة العامل](https://docs.claude-mem.ai/architecture/worker-service)** - HTTP API وإدارة Bun
 - **[قاعدة البيانات](https://docs.claude-mem.ai/architecture/database)** - مخطط SQLite وبحث FTS5
 - **[بنية البحث](https://docs.claude-mem.ai/architecture/search-architecture)** - البحث المختلط مع قاعدة بيانات المتجهات Chroma
@@ -161,24 +167,23 @@

 **المكونات الأساسية:**

-1. **5 خطافات دورة الحياة** - SessionStart، UserPromptSubmit، PostToolUse، Stop، SessionEnd (6 سكريبتات خطافات)
-2. **تثبيت ذكي** - فاحص التبعيات المخزنة مؤقتًا (سكريبت ما قبل الخطاف، ليس خطاف دورة حياة)
+1. **5 برامج ربط (Hooks)** - SessionStart، UserPromptSubmit، PostToolUse، Stop، SessionEnd
+2. **تثبيت ذكي** - فاحص التبعيات المخزنة مؤقتًا
 3. **خدمة العامل** - HTTP API على المنفذ 37777 مع واجهة مستخدم عارض الويب و10 نقاط نهاية للبحث، تديرها Bun
 4. **قاعدة بيانات SQLite** - تخزن الجلسات، الملاحظات، الملخصات
 5. **مهارة mem-search** - استعلامات اللغة الطبيعية مع الكشف التدريجي
-6. **قاعدة بيانات المتجهات Chroma** - البحث المختلط الدلالي + الكلمات المفتاحية لاسترجاع السياق الذكي
+6. **قاعدة بيانات المتجهات Chroma** - البحث الدلالي الهجين + الكلمات المفتاحية لاسترجاع السياق الذكي

 انظر [نظرة عامة على البنية المعمارية](https://docs.claude-mem.ai/architecture/overview) للتفاصيل.

 ---

-## مهارة mem-search
-
+## أدوات البحث (MCP Search Tools)
 يوفر Claude-Mem بحثًا ذكيًا من خلال مهارة mem-search التي تُستدعى تلقائيًا عندما تسأل عن العمل السابق:

 **كيف يعمل:**
 - فقط اسأل بشكل طبيعي: *"ماذا فعلنا في الجلسة الأخيرة؟"* أو *"هل أصلحنا هذا الخطأ من قبل؟"*
- يستدعي Claude تلقائيًا مهارة mem-search للعثور على السياق ذي الصلة
+- يستدعي Claude تلقائيًا خاصية mem-search للعثور على السياق ذي الصلة

 **عمليات البحث المتاحة:**

@@ -193,7 +198,7 @@
 9. **الجدول الزمني حسب الاستعلام** - البحث عن الملاحظات والحصول على سياق الجدول الزمني حول أفضل تطابق
 10. **مساعدة API** - الحصول على توثيق API البحث

-**أمثلة على استعلامات اللغة الطبيعية:**
+**أمثلة على الاستعلامات:**

 ```
 "What bugs did we fix last session?"
@@ -219,8 +224,7 @@

 - **Node.js**: 18.0.0 أو أعلى
 - **Claude Code**: أحدث إصدار مع دعم الإضافات
- **Bun**: بيئة تشغيل JavaScript ومدير العمليات (يُثبت تلقائيًا إذا كان مفقودًا)
- **uv**: مدير حزم Python للبحث المتجهي (يُثبت تلقائيًا إذا كان مفقودًا)
+- **Bun & uv**: (يتم تثبيتهما تلقائياً) لإدارة العمليات والبحث المتجه.
 - **SQLite 3**: للتخزين المستمر (مدمج)

 ---
@@ -241,7 +245,7 @@

 ## استكشاف الأخطاء وإصلاحها

-إذا واجهت مشكلات، صِف المشكلة لـ Claude وستقوم مهارة troubleshoot تلقائيًا بتشخيصها وتوفير الإصلاحات.
+إذا واجهت مشكلة، اشرحها لـ Claude وسيقوم بتشغيل خاصية troubleshoot لإصلاحها ذاتياً.

 انظر **[دليل استكشاف الأخطاء وإصلاحها](https://docs.claude-mem.ai/troubleshooting)** للمشكلات الشائعة والحلول.

@@ -250,27 +254,29 @@
 ## تقارير الأخطاء

 أنشئ تقارير أخطاء شاملة باستخدام المولّد الآلي:
+<div align=left>

 ```bash
 cd ~/.claude/plugins/marketplaces/thedotmack
 npm run bug-report
 ```
+</div>

 ## المساهمة

 المساهمات مرحب بها! يُرجى:

-1. عمل Fork للمستودع
-2. إنشاء فرع ميزة
+1. عمل Fork للمشروع (Repository)
+2. إنشاء فرع (branch)
 3. إجراء التغييرات مع الاختبارات
-4. تحديث التوثيق
+4. تحديث المستندات عند الحاجه
 5. تقديم Pull Request

 انظر [دليل التطوير](https://docs.claude-mem.ai/development) لسير عمل المساهمة.

 ---

-## الترخيص
+## الترخيص (License)

 هذا المشروع مرخص بموجب **ترخيص GNU Affero العام الإصدار 3.0** (AGPL-3.0).

@@ -298,4 +304,6 @@ npm run bug-report

 ---

-**مبني باستخدام Claude Agent SDK** | **مدعوم بواسطة Claude Code** | **صُنع باستخدام TypeScript**
+**مبني باستخدام Claude Agent SDK** | **مدعوم بواسطة Claude Code** | **صُنع باستخدام TypeScript**
+
+</section>
@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Claude Code পুনরায় চালু করুন। পূর্ব

 ## ডকুমেন্টেশন

-📚 **[সম্পূর্ণ ডকুমেন্টেশন দেখুন](docs/)** - GitHub-এ markdown ডক্স ব্রাউজ করুন
+📚 **[সম্পূর্ণ ডকুমেন্টেশন দেখুন](https://docs.claude-mem.ai/)** - অফিসিয়াল ওয়েবসাইটে ব্রাউজ করুন

 ### শুরু করা

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Restartujte Claude Code. Kontext z předchozích sezení se automaticky objeví

 ## Dokumentace

-📚 **[Zobrazit kompletní dokumentaci](docs/)** - Procházejte dokumentaci v markdown na GitHubu
+📚 **[Zobrazit kompletní dokumentaci](https://docs.claude-mem.ai/)** - Procházet na oficiálních stránkách

 ### Začínáme

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Genstart Claude Code. Kontekst fra tidligere sessioner vil automatisk vises i ny

 ## Dokumentation

-📚 **[Se Fuld Dokumentation](docs/)** - Gennemse markdown-dokumenter på GitHub
+📚 **[Se Fuld Dokumentation](https://docs.claude-mem.ai/)** - Gennemse på den officielle hjemmeside

 ### Kom Godt I Gang

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Starten Sie Claude Code neu. Kontext aus vorherigen Sitzungen wird automatisch i

 ## Dokumentation

-📚 **[Vollständige Dokumentation anzeigen](docs/)** - Markdown-Dokumentation auf GitHub durchsuchen
+📚 **[Vollständige Dokumentation anzeigen](https://docs.claude-mem.ai/)** - Auf der offiziellen Website durchsuchen

 ### Erste Schritte

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@

 ## Τεκμηρίωση

-📚 **[Προβολή Πλήρους Τεκμηρίωσης](docs/)** - Περιήγηση στα markdown έγγραφα στο GitHub
+📚 **[Προβολή Πλήρους Τεκμηρίωσης](https://docs.claude-mem.ai/)** - Περιήγηση στον επίσημο ιστότοπο

 ### Ξεκινώντας

@@ -16,6 +16,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -35,6 +36,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -127,7 +129,7 @@ Reinicia Claude Code. El contexto de sesiones anteriores aparecerá automáticam

 ## Documentación

-📚 **[Ver Documentación Completa](docs/)** - Explora documentos markdown en GitHub
+📚 **[Ver Documentación Completa](https://docs.claude-mem.ai/)** - Navegar en el sitio web oficial

 ### Primeros Pasos

@@ -14,6 +14,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +34,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -125,7 +127,7 @@ Käynnistä Claude Code uudelleen. Aiempien istuntojen konteksti ilmestyy automa

 ## Dokumentaatio

-📚 **[Näytä täydellinen dokumentaatio](docs/)** - Selaa markdown-dokumentteja GitHubissa
+📚 **[Näytä täydellinen dokumentaatio](https://docs.claude-mem.ai/)** - Selaa virallisella verkkosivustolla

 ### Aloitus

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Redémarrez Claude Code. Le contexte des sessions précédentes apparaîtra auto

 ## Documentation

-📚 **[Voir la documentation complète](docs/)** - Parcourez la documentation markdown sur GitHub
+📚 **[Voir la documentation complète](https://docs.claude-mem.ai/)** - Parcourir sur le site officiel

 ### Pour commencer

@@ -14,6 +14,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +34,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -125,7 +127,7 @@

 ## תיעוד

-📚 **[צפה בתיעוד המלא](docs/)** - עיין במסמכי markdown ב-GitHub
+📚 **[צפה בתיעוד המלא](https://docs.claude-mem.ai/)** - דפדף באתר הרשמי

 ### תחילת העבודה

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Claude Code को पुनः आरंभ करें। पिछले स

 ## दस्तावेज़ीकरण

-📚 **[पूर्ण दस्तावेज़ीकरण देखें](docs/)** - GitHub पर markdown दस्तावेज़ ब्राउज़ करें
+📚 **[पूर्ण दस्तावेज़ीकरण देखें](https://docs.claude-mem.ai/)** - आधिकारिक वेबसाइट पर ब्राउज़ करें

 ### शुरुआत करना

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Indítsa újra a Claude Code-ot. A korábbi munkamenetek kontextusa automatikusa

 ## Dokumentáció

-📚 **[Teljes dokumentáció megtekintése](docs/)** - Markdown dokumentumok böngészése GitHub-on
+📚 **[Teljes dokumentáció megtekintése](https://docs.claude-mem.ai/)** - Böngészés a hivatalos weboldalon

 ### Első lépések

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Restart Claude Code. Konteks dari sesi sebelumnya akan secara otomatis muncul di

 ## Dokumentasi

-📚 **[Lihat Dokumentasi Lengkap](docs/)** - Telusuri dokumen markdown di GitHub
+📚 **[Lihat Dokumentasi Lengkap](https://docs.claude-mem.ai/)** - Jelajahi di situs web resmi

 ### Memulai

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Riavvia Claude Code. Il contesto delle sessioni precedenti apparirà automaticam

 ## Documentazione

-📚 **[Visualizza Documentazione Completa](docs/)** - Sfoglia i documenti markdown su GitHub
+📚 **[Visualizza Documentazione Completa](https://docs.claude-mem.ai/)** - Sfoglia sul sito ufficiale

 ### Per Iniziare

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Claude Codeを再起動します。以前のセッションからのコンテキ

 ## ドキュメント

-📚 **[完全なドキュメントを見る](docs/)** - GitHubでマークダウンドキュメントを閲覧
+📚 **[完全なドキュメントを見る](https://docs.claude-mem.ai/)** - 公式ウェブサイトで閲覧

 ### はじめに

@@ -212,7 +214,7 @@ Claude-Memは、過去の作業について尋ねると自動的に呼び出さ

 Claude-Memは、**Endless Mode**(拡張セッション用の生体模倣メモリアーキテクチャ)などの実験的機能を備えた**ベータチャネル**を提供します。http://localhost:37777 → SettingsのWebビューアUIから安定版とベータ版を切り替えます。

-Endless Modeと試用方法の詳細については、**[ベータ機能ドキュメント](https://docs.claude-mem.ai/beta-features)**を参照してください。
+Endless Modeと試用方法の詳細については、**[ベータ機能ドキュメント](https://docs.claude-mem.ai/beta-features)** を参照してください。

 ---

@@ -230,13 +232,13 @@ Endless Modeと試用方法の詳細については、**[ベータ機能ドキ

 設定は`~/.claude-mem/settings.json`で管理されます(初回実行時にデフォルト値で自動作成)。AIモデル、ワーカーポート、データディレクトリ、ログレベル、コンテキスト注入設定を構成します。

-利用可能なすべての設定と例については、**[設定ガイド](https://docs.claude-mem.ai/configuration)**を参照してください。
+利用可能なすべての設定と例については、**[設定ガイド](https://docs.claude-mem.ai/configuration)** を参照してください。

 ---

 ## 開発

-ビルド手順、テスト、コントリビューションワークフローについては、**[開発ガイド](https://docs.claude-mem.ai/development)**を参照してください。
+ビルド手順、テスト、コントリビューションワークフローについては、**[開発ガイド](https://docs.claude-mem.ai/development)** を参照してください。

 ---

@@ -244,7 +246,7 @@ Endless Modeと試用方法の詳細については、**[ベータ機能ドキ

 問題が発生した場合は、Claudeに問題を説明すると、troubleshootスキルが自動的に診断して修正を提供します。

-よくある問題と解決策については、**[トラブルシューティングガイド](https://docs.claude-mem.ai/troubleshooting)**を参照してください。
+よくある問題と解決策については、**[トラブルシューティングガイド](https://docs.claude-mem.ai/troubleshooting)** を参照してください。

 ---

@@ -286,7 +288,7 @@ Copyright (C) 2025 Alex Newman (@thedotmack). All rights reserved.
 - 派生作品もAGPL-3.0の下でライセンスする必要があります
 - このソフトウェアには保証がありません

-**Ragtimeに関する注意**: `ragtime/`ディレクトリは**PolyForm Noncommercial License 1.0.0**の下で個別にライセンスされています。詳細は[ragtime/LICENSE](ragtime/LICENSE)を参照してください。
+**Ragtimeに関する注意**: `ragtime/`ディレクトリは **PolyForm Noncommercial License 1.0.0** の下で個別にライセンスされています。詳細は[ragtime/LICENSE](ragtime/LICENSE)を参照してください。

 ---

@@ -299,4 +301,4 @@ Copyright (C) 2025 Alex Newman (@thedotmack). All rights reserved.

 ---

-**Claude Agent SDKで構築** | **Claude Codeで動作** | **TypeScriptで作成**
+**Claude Agent SDKで構築** | **Claude Codeで動作** | **TypeScriptで作成**
@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -114,19 +116,19 @@ Claude Code를 재시작하세요. 이전 세션의 컨텍스트가 자동으로
 - 🧠 **지속적인 메모리** - 세션 간 컨텍스트 유지
 - 📊 **점진적 공개** - 토큰 비용 가시성을 갖춘 계층화된 메모리 검색
 - 🔍 **스킬 기반 검색** - mem-search 스킬로 프로젝트 기록 쿼리
- 🖥️ **웹 뷰어 UI** - http://localhost:37777에서 실시간 메모리 스트림 확인
+- 🖥️ **웹 뷰어 UI** - http://localhost:37777 에서 실시간 메모리 스트림 확인
 - 💻 **Claude Desktop 스킬** - Claude Desktop 대화에서 메모리 검색
 - 🔒 **개인정보 제어** - `<private>` 태그를 사용하여 민감한 콘텐츠를 저장소에서 제외
 - ⚙️ **컨텍스트 설정** - 주입되는 컨텍스트에 대한 세밀한 제어
 - 🤖 **자동 작동** - 수동 개입 불필요
- 🔗 **인용** - ID로 과거 관찰 참조 (http://localhost:37777/api/observation/{id}를 통해 액세스하거나 http://localhost:37777의 웹 뷰어에서 모두 보기)
+- 🔗 **인용** - ID로 과거 관찰 참조 (http://localhost:37777/api/observation/{id} 를 통해 액세스하거나 http://localhost:37777 의 웹 뷰어에서 모두 보기)
 - 🧪 **베타 채널** - 버전 전환을 통해 Endless Mode와 같은 실험적 기능 사용

 ---

 ## 문서

-📚 **[전체 문서 보기](docs/)** - GitHub에서 마크다운 문서 탐색
+📚 **[전체 문서 보기](https://docs.claude-mem.ai/)** - 공식 웹사이트에서 찾아보기

 ### 시작하기

@@ -14,6 +14,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +34,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -125,7 +127,7 @@ Herstart Claude Code. Context van eerdere sessies verschijnt automatisch in nieu

 ## Documentatie

-📚 **[Bekijk Volledige Documentatie](docs/)** - Blader door markdown documenten op GitHub
+📚 **[Bekijk Volledige Documentatie](https://docs.claude-mem.ai/)** - Bladeren op de officiële website

 ### Aan de Slag

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Start Claude Code på nytt. Kontekst fra tidligere økter vil automatisk vises i

 ## Dokumentasjon

-📚 **[Se Full Dokumentasjon](docs/)** - Bla gjennom markdown-dokumenter på GitHub
+📚 **[Se Full Dokumentasjon](https://docs.claude-mem.ai/)** - Bla gjennom på det offisielle nettstedet

 ### Komme I Gang

@@ -14,6 +14,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +34,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -125,7 +127,7 @@ Uruchom ponownie Claude Code. Kontekst z poprzednich sesji automatycznie pojawi

 ## Dokumentacja

-📚 **[Wyświetl Pełną Dokumentację](docs/)** - Przeglądaj dokumentację markdown na GitHub
+📚 **[Wyświetl Pełną Dokumentację](https://docs.claude-mem.ai/)** - Przeglądaj na oficjalnej stronie

 ### Pierwsze Kroki

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Reinicie o Claude Code. O contexto de sessões anteriores aparecerá automaticam

 ## Documentação

-📚 **[Ver Documentação Completa](docs/)** - Navegue pelos documentos markdown no GitHub
+📚 **[Ver Documentação Completa](https://docs.claude-mem.ai/)** - Navegar no site oficial

 ### Começando

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Reporniți Claude Code. Contextul din sesiunile anterioare va apărea automat î

 ## Documentație

-📚 **[Vizualizați Documentația Completă](docs/)** - Răsfoiți documentele markdown pe GitHub
+📚 **[Vizualizați Documentația Completă](https://docs.claude-mem.ai/)** - Răsfoiți pe site-ul oficial

 ### Introducere

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@

 ## Документация

-📚 **[Просмотреть полную документацию](docs/)** - Просмотр markdown-документов на GitHub
+📚 **[Просмотреть полную документацию](https://docs.claude-mem.ai/)** - Просмотр на официальном сайте

 ### Начало работы

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Starta om Claude Code. Kontext från tidigare sessioner kommer automatiskt att v

 ## Dokumentation

-📚 **[Visa fullständig dokumentation](docs/)** - Bläddra bland markdown-dokument på GitHub
+📚 **[Visa fullständig dokumentation](https://docs.claude-mem.ai/)** - Bläddra på den officiella webbplatsen

 ### Komma igång

@@ -14,6 +14,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +34,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -125,7 +127,7 @@

 ## เอกสาร

-📚 **[ดูเอกสารฉบับเต็ม](docs/)** - เรียกดูเอกสาร markdown บน GitHub
+📚 **[ดูเอกสารฉบับเต็ม](https://docs.claude-mem.ai/)** - เรียกดูบนเว็บไซต์อย่างเป็นทางการ

 ### เริ่มต้นใช้งาน

@@ -14,6 +14,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -33,6 +34,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -125,7 +127,7 @@ Claude Code'u yeniden başlatın. Önceki oturumlardaki bağlam otomatik olarak

 ## Dokümantasyon

-📚 **[Tam Dokümantasyonu Görüntüle](docs/)** - GitHub'da markdown dökümanlarına göz atın
+📚 **[Tam Dokümantasyonu Görüntüle](https://docs.claude-mem.ai/)** - Resmi web sitesinde göz atın

 ### Başlarken

@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@

 ## Документація

-📚 **[Переглянути повну документацію](docs/)** - Переглядайте markdown документи на GitHub
+📚 **[Переглянути повну документацію](https://docs.claude-mem.ai/)** - Переглянути на офіційному сайті

 ### Початок роботи

@@ -0,0 +1,311 @@
+<section dir="rtl">
+🌐 یہ ایک خودکار ترجمہ ہے۔ کمیونٹی کی اصلاحات کا خیر مقدم ہے!
+
+---
+<h1 align="center">
+  <br>
+  <a href="https://github.com/thedotmack/claude-mem">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/claude-mem-logo-for-dark-mode.webp">
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/claude-mem-logo-for-light-mode.webp">
+      <img src="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/claude-mem-logo-for-light-mode.webp" alt="Claude-Mem" width="400">
+    </picture>
+  </a>
+  <br>
+</h1>
+
+<p align="center" dir="ltr">
+  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.ja.md">🇯🇵 日本語</a> •
+  <a href="README.pt-br.md">🇧🇷 Português</a> •
+  <a href="README.ko.md">🇰🇷 한국어</a> •
+  <a href="README.es.md">🇪🇸 Español</a> •
+  <a href="README.de.md">🇩🇪 Deutsch</a> •
+  <a href="README.fr.md">🇫🇷 Français</a>
+  <a href="README.he.md">🇮🇱 עברית</a> •
+  <a href="README.ar.md">🇸🇦 العربية</a> •
+  <a href="README.ru.md">🇷🇺 Русский</a> •
+  <a href="README.pl.md">🇵🇱 Polski</a> •
+  <a href="README.cs.md">🇨🇿 Čeština</a> •
+  <a href="README.nl.md">🇳🇱 Nederlands</a> •
+  <a href="README.tr.md">🇹🇷 Türkçe</a> •
+  <a href="README.uk.md">🇺🇦 Українська</a> •
+  <a href="README.vi.md">🇻🇳 Tiếng Việt</a> •
+  <a href="README.id.md">🇮🇩 Indonesia</a> •
+  <a href="README.th.md">🇹🇭 ไทย</a> •
+  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
+  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
+  <a href="README.ro.md">🇷🇴 Română</a> •
+  <a href="README.sv.md">🇸🇪 Svenska</a> •
+  <a href="README.it.md">🇮🇹 Italiano</a> •
+  <a href="README.el.md">🇬🇷 Ελληνικά</a> •
+  <a href="README.hu.md">🇭🇺 Magyar</a> •
+  <a href="README.fi.md">🇫🇮 Suomi</a> •
+  <a href="README.da.md">🇩🇰 Dansk</a> •
+  <a href="README.no.md">🇳🇴 Norsk</a>
+</p>
+
+<h4 align="center"><a href="https://claude.com/claude-code" target="_blank">Claude Code</a> کے لیے بنایا گیا مستقل میموری کمپریشن سسٹم۔</h4>
+
+<p align="center">
+  <a href="LICENSE">
+    <img src="https://img.shields.io/badge/License-AGPL%203.0-blue.svg" alt="License">
+  </a>
+  <a href="package.json">
+    <img src="https://img.shields.io/badge/version-6.5.0-green.svg" alt="Version">
+  </a>
+  <a href="package.json">
+    <img src="https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg" alt="Node">
+  </a>
+  <a href="https://github.com/thedotmack/awesome-claude-code">
+    <img src="https://awesome.re/mentioned-badge.svg" alt="Mentioned in Awesome Claude Code">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://trendshift.io/repositories/15496" target="_blank">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/trendshift-badge-dark.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/trendshift-badge.svg">
+      <img src="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/trendshift-badge.svg" alt="thedotmack/claude-mem | Trendshift" width="250" height="55"/>
+    </picture>
+  </a>
+</p>
+
+<br>
+
+<p align="center">
+  <a href="https://github.com/thedotmack/claude-mem">
+    <picture>
+      <img src="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/cm-preview.gif" alt="Claude-Mem Preview" width="800">
+    </picture>
+  </a>
+</p>
+
+<p align="center">
+  <a href="#تیز-رفتار-شروعات">تیز رفتار شروعات</a> •
+  <a href="#یہ-کیسے-کام-کرتا-ہے">یہ کیسے کام کرتا ہے</a> •
+  <a href="#تلاش-کے-اوزار">تلاش کے اوزار</a> •
+  <a href="#دستاویزات">دستاویزات</a> •
+  <a href="#ترتیبات">ترتیبات</a> •
+  <a href="#مسائل-کی-تشخیص">مسائل کی تشخیص</a> •
+  <a href="#لائسنس">لائسنس</a>
+</p>
+
+<p align="center">
+  Claude-Mem خودکار طور پر ٹول کے استعمال کے بعد کے مشاہدات کو ریکارڈ کرتا ہے، سیمانٹک خلاصے تیار کرتا ہے اور انہیں مستقبل کے سیشنز میں دستیاب کرتا ہے تاکہ آپ سیشن میں براہ راست تناسب محفوظ رہے۔ یہ Claude کو سیشن ختم ہونے یا دوبارہ جڑنے کے بعد بھی منصوبے کے بارے میں معلومات کی مسلسلیت برقرار رکھنے کے قابل بناتا ہے۔
+</p>
+
+---
+
+## تیز رفتار شروعات
+
+ٹرمنل میں نیا Claude Code سیشن شروع کریں اور ہیں کمانڈز درج کریں:
+
+```
+> /plugin marketplace add thedotmack/claude-mem
+
+> /plugin install claude-mem
+```
+
+Claude Code کو دوبارہ شروع کریں۔ سابقہ سیشن کا تناسب خودکار طور پر نئے سیشن میں موجود ہوگا۔
+
+**اہم خصوصیات:**
+
+- 🧠 **مستقل میموری** - تناسب سیشن کے دوران برقرار رہتا ہے
+- 📊 **بتدریج ظہور** - لیئرڈ میموری کی بازیافت ٹوکن کی لاگت کی نمائندگی کے ساتھ
+- 🔍 **کمکردہ تلاش** - mem-search مہارت کے ساتھ اپنے منصوبے کی تاریخ میں تلاش کریں
+- 🖥️ **ویب ویور یو آئی** - http://localhost:37777 پر حقیقی وقت میموری اسٹریم
+- 💻 **Claude Desktop مہارت** - Claude Desktop بات چیت سے میموری تلاش کریں
+- 🔒 **رازداری کے کنٹرولز** - حساس مواد کو ذخیرہ سے خارج کرنے کے لیے `<private>` ٹیگ استعمال کریں
+- ⚙️ **تناسب کی ترتیبات** - کون سا تناسب انجیکٹ کیا جائے اس پر باریک کنٹرول
+- 🤖 **خودکار آپریشن** - کسی دستی مداخلت کی ضرورت نہیں
+- 🔗 **حوالہ** - ID کے ذریعے سابقہ مشاہدات کا حوالہ دیں (http://localhost:37777/api/observation/{id} کے ذریعے رسائی حاصل کریں یا تمام کو http://localhost:37777 پر ویب ویور میں دیکھیں)
+- 🧪 **بیٹا چینل** - ورژن تبدیل کرنے کے ذریعے Endless Mode جیسی تجرباتی خصوصیات آزمائیں
+
+---
+
+## دستاویزات
+
+📚 **[مکمل دستاویزات دیکھیں](docs/)** - GitHub پر markdown ڈاکس کو براؤز کریں
+
+### شروعات کرنا
+
+- **[انسٹالیشن گائیڈ](https://docs.claude-mem.ai/installation)** - تیز رفتار شروعات اور اعلیٰ درجے کی انسٹالیشن
+- **[استعمال گائیڈ](https://docs.claude-mem.ai/usage/getting-started)** - Claude-Mem خودکار طور پر کیسے کام کرتا ہے
+- **[تلاش کے اوزار](https://docs.claude-mem.ai/usage/search-tools)** - قدرتی زبان کے ساتھ اپنے منصوبے کی تاریخ میں تلاش کریں
+- **[بیٹا خصوصیات](https://docs.claude-mem.ai/beta-features)** - Endless Mode جیسی تجرباتی خصوصیات آزمائیں
+
+### بہترین طریقہ کار
+
+- **[تناسب انجینیئرنگ](https://docs.claude-mem.ai/context-engineering)** - AI ایجنٹ کے تناسب کی اہمیت کے اصول
+- **[بتدریج ظہور](https://docs.claude-mem.ai/progressive-disclosure)** - Claude-Mem کے تناسب کی تیاری کی حکمت عملی کے پیچھے فلسفہ
+
+### تعمیر
+
+- **[جائزہ](https://docs.claude-mem.ai/architecture/overview)** - نظام کے اجزاء اور ڈیٹا کے بہاؤ
+- **[تعمیر کا ارتقاء](https://docs.claude-mem.ai/architecture-evolution)** - v3 سے v5 تک کا سفر
+- **[ہکس تعمیر](https://docs.claude-mem.ai/hooks-architecture)** - Claude-Mem لائف سائیکل ہکس کا استعمال کیسے کرتا ہے
+- **[ہکس حوالہ](https://docs.claude-mem.ai/architecture/hooks)** - 7 ہک اسکرپٹس کی تشریح
+- **[ورکر سروس](https://docs.claude-mem.ai/architecture/worker-service)** - HTTP API اور Bun انتظام
+- **[ڈیٹا بیس](https://docs.claude-mem.ai/architecture/database)** - SQLite اسکیما اور FTS5 تلاش
+- **[تلاش تعمیر](https://docs.claude-mem.ai/architecture/search-architecture)** - Chroma ویکٹر ڈیٹا بیس کے ساتھ ہائبرڈ تلاش
+
+### ترتیبات اور ترقی
+
+- **[ترتیبات](https://docs.claude-mem.ai/configuration)** - ماحول کے متغیرات اور سیٹنگز
+- **[ترقی](https://docs.claude-mem.ai/development)** - تعمیر، جانچ، حصہ داری
+- **[مسائل کی تشخیص](https://docs.claude-mem.ai/troubleshooting)** - عام مسائل اور حل
+
+---
+
+## یہ کیسے کام کرتا ہے
+
+**اہم اجزاء:**
+
+1. **5 لائف سائیکل ہکس** - SessionStart، UserPromptSubmit، PostToolUse، Stop، SessionEnd (6 ہک اسکرپٹس)
+2. **سمارٹ انسٹالیشن** - کیش شدہ منحصرات چیکر (پری ہک اسکرپٹ، لائف سائیکل ہک نہیں)
+3. **ورکر سروس** - ویب ویور UI اور 10 تلاش کے endpoints کے ساتھ پورٹ 37777 پر HTTP API، Bun کے ذریعے برتاؤ
+4. **SQLite ڈیٹا بیس** - سیشنز، مشاہدات، خلاصہ ذخیرہ کرتا ہے
+5. **mem-search مہارت** - بتدریج ظہور کے ساتھ قدرتی زبان کے سوالات
+6. **Chroma ویکٹر ڈیٹا بیس** - ہائبرڈ سیمانٹک + کلیدی لفظ تلاش ذہین تناسب کی بازیافت کے لیے
+
+تفصیلات کے لیے [تعمیر کا جائزہ](https://docs.claude-mem.ai/architecture/overview) دیکھیں۔
+
+---
+
+## MCP تلاش کے اوزار
+
+Claude-Mem ٹوکن-موثر **3-لیئر ورک فلو پیٹرن** کی پیروی کرتے ہوئے **4 MCP اوزار** کے ذریعے ذہین میموری تلاش فراہم کرتا ہے:
+
+**3-لیئر ورک فلو:**
+
+1. **`search`** - IDs کے ساتھ کمپیکٹ انڈیکس حاصل کریں (~50-100 ٹوکن/نتیجہ)
+2. **`timeline`** - دلچسپ نتائج کے ارد گرد زمانی تناسب حاصل کریں
+3. **`get_observations`** - فلٹر شدہ IDs کے لیے صرف مکمل تفصیلات حاصل کریں (~500-1,000 ٹوکن/نتیجہ)
+
+**یہ کیسے کام کرتا ہے:**
+- Claude آپ کی میموری میں تلاش کے لیے MCP اوزار استعمال کرتا ہے
+- نتائج کا انڈیکس حاصل کرنے کے لیے `search` سے شروع کریں
+- مخصوص مشاہدات کے ارد گرد کیا ہو رہا تھا دیکھنے کے لیے `timeline` استعمال کریں
+- متعلقہ IDs کے لیے مکمل تفصیلات حاصل کرنے کے لیے `get_observations` استعمال کریں
+- تفصیلات حاصل کرنے سے پہلے فلٹرنگ کے ذریعے **~10x ٹوکن کی بچت**
+
+**دستیاب MCP اوزار:**
+
+1. **`search`** - مکمل متن کی تلاش کے سوالات کے ساتھ میموری انڈیکس تلاش کریں، قسم/تاریخ/منصوبے کے لحاظ سے فلٹر کریں
+2. **`timeline`** - مخصوص مشاہدہ یا سوال کے ارد گرد زمانی تناسب حاصل کریں
+3. **`get_observations`** - IDs کے ذریعے مکمل مشاہدہ تفصیلات حاصل کریں (ہمیشہ متعدد IDs کو بیچ کریں)
+4. **`__IMPORTANT`** - ورک فلو دستاویزات (ہمیشہ Claude کو نظر آتی ہے)
+
+**استعمال کی مثال:**
+
+```typescript
+// مرحلہ 1: انڈیکس کے لیے تلاش کریں
+search(query="authentication bug", type="bugfix", limit=10)
+
+// مرحلہ 2: انڈیکس کا جائزہ لیں، متعلقہ IDs کی شناخت کریں (مثلاً، #123, #456)
+
+// مرحلہ 3: مکمل تفصیلات حاصل کریں
+get_observations(ids=[123, 456])
+```
+
+تفصیلی مثالوں کے لیے [تلاش کے اوزار گائیڈ](https://docs.claude-mem.ai/usage/search-tools) دیکھیں۔
+
+---
+
+## بیٹا خصوصیات
+
+Claude-Mem ایک **بیٹا چینل** فراہم کرتا ہے جس میں **Endless Mode** جیسی تجرباتی خصوصیات ہیں (بڑھی ہوئی سیشنز کے لیے حیاتی نقل میموری کی تعمیر)۔ http://localhost:37777 → Settings میں ویب ویور UI سے مستحکم اور بیٹا ورژن کے درمیان سوئچ کریں۔
+
+Endless Mode اور اسے کیسے آزمائیں اس کے بارے میں تفصیلات کے لیے **[بیٹا خصوصیات دستاویزات](https://docs.claude-mem.ai/beta-features)** دیکھیں۔
+
+---
+
+## نظام کی ضروریات
+
+- **Node.js**: 18.0.0 یا اس سے اوپر
+- **Claude Code**: پلگ ان سپورٹ کے ساتھ جدید ترین ورژن
+- **Bun**: JavaScript رن ٹائم اور پروسیس مینیجر (غیر موجود ہو تو خودکار طور پر انسٹال ہوگا)
+- **uv**: ویکٹر تلاش کے لیے Python پیکج مینیجر (غیر موجود ہو تو خودکار طور پر انسٹال ہوگا)
+- **SQLite 3**: مستقل اسٹوریج کے لیے (بنڈل شدہ)
+
+---
+
+## ترتیبات
+
+سیٹنگز `~/.claude-mem/settings.json` میں منظم ہیں (پہلی رن میں ڈیفالٹ کے ساتھ خودکار طور پر بنائی جاتی ہے)۔ AI ماڈل، ورکر پورٹ، ڈیٹا ڈائریکٹری، لاگ لیول اور تناسب انجیکشن سیٹنگز کو ترتیب دیں۔
+
+تمام دستیاب سیٹنگز اور مثالوں کے لیے **[ترتیبات گائیڈ](https://docs.claude-mem.ai/configuration)** دیکھیں۔
+
+---
+
+## ترقی
+
+تعمیر کی ہدایات، جانچ اور حصہ داری کے کام کے بہاؤ کے لیے **[ترقی گائیڈ](https://docs.claude-mem.ai/development)** دیکھیں۔
+
+---
+
+## مسائل کی تشخیص
+
+اگر مسائل کا سامنا ہو تو Claude کو مسئلہ بتائیں اور troubleshoot مہارت خودکار طور پر تشخیص دے گی اور حل فراہم کرے گی۔
+
+عام مسائل اور حل کے لیے **[مسائل کی تشخیص گائیڈ](https://docs.claude-mem.ai/troubleshooting)** دیکھیں۔
+
+---
+
+## خرابی کی رپورٹ
+
+خودکار جنریٹر کے ساتھ تفصیلی خرابی کی رپورٹ تیار کریں:
+
+```bash
+cd ~/.claude/plugins/marketplaces/thedotmack
+npm run bug-report
+```
+
+## حصہ داری
+
+حصہ داری کا خیر مقدم ہے! براہ کرم:
+
+1. رپوزیٹری کو فورک کریں
+2. ایک خصوصیت کی برانچ بنائیں
+3. ٹیسٹ کے ساتھ اپنی تبدیلیاں کریں
+4. دستاویزات کو اپڈیٹ کریں
+5. ایک Pull Request جمع کریں
+
+حصہ داری کے کام کے بہاؤ کے لیے [ترقی گائیڈ](https://docs.claude-mem.ai/development) دیکھیں۔
+
+---
+
+## لائسنس
+
+یہ منصوبہ **GNU Affero General Public License v3.0** (AGPL-3.0) کے تحت لائسنس ہے۔
+
+Copyright (C) 2025 Alex Newman (@thedotmack)۔ تمام حقوق محفوظ ہیں۔
+
+مکمل تفصیلات کے لیے [LICENSE](LICENSE) فائل دیکھیں۔
+
+**اس کا مطلب کیا ہے:**
+
+- آپ اس سافٹ ویئر کو آزادی سے استعمال، تبدیل اور تقسیم کر سکتے ہیں
+- اگر آپ اسے تبدیل کریں اور نیٹ ورک سرور میں نشر کریں تو آپ کو اپنا سورس کوڈ دستیاب کرنا ہوگا
+- ماخوذ کام بھی AGPL-3.0 کے تحت لائسنس ہونے چاہیں
+- اس سافٹ ویئر کے لیے کوئی وارنٹی نہیں
+
+**Ragtime کے بارے میں نوٹ**: `ragtime/` ڈائریکٹری الگ سے **PolyForm Noncommercial License 1.0.0** کے تحت لائسنس ہے۔ تفصیلات کے لیے [ragtime/LICENSE](ragtime/LICENSE) دیکھیں۔
+
+---
+
+## معاونت
+
+- **دستاویزات**: [docs/](docs/)
+- **مسائل**: [GitHub Issues](https://github.com/thedotmack/claude-mem/issues)
+- **رپوزیٹری**: [github.com/thedotmack/claude-mem](https://github.com/thedotmack/claude-mem)
+- **مصنف**: Alex Newman ([@thedotmack](https://github.com/thedotmack))
+
+---
+
+**Claude Agent SDK کے ساتھ بنایا گیا** | **Claude Code کے ذریعے طاقت ور** | **TypeScript کے ساتھ بنایا گیا**
+
+</section>
@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@ Khởi động lại Claude Code. Ngữ cảnh từ các phiên trước sẽ t

 ## Tài Liệu

-📚 **[Xem Tài Liệu Đầy Đủ](docs/)** - Duyệt tài liệu markdown trên GitHub
+📚 **[Xem Tài Liệu Đầy Đủ](https://docs.claude-mem.ai/)** - Duyệt trên trang web chính thức

 ### Bắt Đầu

@@ -0,0 +1,311 @@
+🌐 這是自動翻譯。歡迎社群貢獻修正！
+
+---
+<h1 align="center">
+  <br>
+  <a href="https://github.com/thedotmack/claude-mem">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/claude-mem-logo-for-dark-mode.webp">
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/claude-mem-logo-for-light-mode.webp">
+      <img src="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/claude-mem-logo-for-light-mode.webp" alt="Claude-Mem" width="400">
+    </picture>
+  </a>
+  <br>
+</h1>
+
+<p align="center">
+  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
+  <a href="README.ja.md">🇯🇵 日本語</a> •
+  <a href="README.pt-br.md">🇧🇷 Português</a> •
+  <a href="README.ko.md">🇰🇷 한국어</a> •
+  <a href="README.es.md">🇪🇸 Español</a> •
+  <a href="README.de.md">🇩🇪 Deutsch</a> •
+  <a href="README.fr.md">🇫🇷 Français</a>
+  <a href="README.he.md">🇮🇱 עברית</a> •
+  <a href="README.ar.md">🇸🇦 العربية</a> •
+  <a href="README.ru.md">🇷🇺 Русский</a> •
+  <a href="README.pl.md">🇵🇱 Polski</a> •
+  <a href="README.cs.md">🇨🇿 Čeština</a> •
+  <a href="README.nl.md">🇳🇱 Nederlands</a> •
+  <a href="README.tr.md">🇹🇷 Türkçe</a> •
+  <a href="README.uk.md">🇺🇦 Українська</a> •
+  <a href="README.vi.md">🇻🇳 Tiếng Việt</a> •
+  <a href="README.id.md">🇮🇩 Indonesia</a> •
+  <a href="README.th.md">🇹🇭 ไทย</a> •
+  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
+  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ro.md">🇷🇴 Română</a> •
+  <a href="README.sv.md">🇸🇪 Svenska</a> •
+  <a href="README.it.md">🇮🇹 Italiano</a> •
+  <a href="README.el.md">🇬🇷 Ελληνικά</a> •
+  <a href="README.hu.md">🇭🇺 Magyar</a> •
+  <a href="README.fi.md">🇫🇮 Suomi</a> •
+  <a href="README.da.md">🇩🇰 Dansk</a> •
+  <a href="README.no.md">🇳🇴 Norsk</a>
+</p>
+
+<h4 align="center">為 <a href="https://claude.com/claude-code" target="_blank">Claude Code</a> 打造的持久記憶壓縮系統</h4>
+
+<p align="center">
+  <a href="LICENSE">
+    <img src="https://img.shields.io/badge/License-AGPL%203.0-blue.svg" alt="License">
+  </a>
+  <a href="package.json">
+    <img src="https://img.shields.io/badge/version-6.5.0-green.svg" alt="Version">
+  </a>
+  <a href="package.json">
+    <img src="https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg" alt="Node">
+  </a>
+  <a href="https://github.com/thedotmack/awesome-claude-code">
+    <img src="https://awesome.re/mentioned-badge.svg" alt="Mentioned in Awesome Claude Code">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://trendshift.io/repositories/15496" target="_blank">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/trendshift-badge-dark.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/trendshift-badge.svg">
+      <img src="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/trendshift-badge.svg" alt="thedotmack/claude-mem | Trendshift" width="250" height="55"/>
+    </picture>
+  </a>
+</p>
+
+<br>
+
+<p align="center">
+  <a href="https://github.com/thedotmack/claude-mem">
+    <picture>
+      <img src="https://raw.githubusercontent.com/thedotmack/claude-mem/main/docs/public/cm-preview.gif" alt="Claude-Mem Preview" width="800">
+    </picture>
+  </a>
+</p>
+
+<p align="center">
+  <a href="#快速開始">快速開始</a> •
+  <a href="#運作原理">運作原理</a> •
+  <a href="#mcp-搜尋工具">搜尋工具</a> •
+  <a href="#文件">文件</a> •
+  <a href="#設定">設定</a> •
+  <a href="#疑難排解">疑難排解</a> •
+  <a href="#授權條款">授權條款</a>
+</p>
+
+<p align="center">
+  Claude-Mem 透過自動擷取工具使用觀察、產生語意摘要並在未來的工作階段中提供使用，無縫保留跨工作階段的脈絡。這使 Claude 即使在工作階段結束或重新連線後，仍能維持對專案的知識連續性。
+</p>
+
+---
+
+## 快速開始
+
+在終端機中開啟新的 Claude Code 工作階段，並輸入以下指令：
+
+```
+> /plugin marketplace add thedotmack/claude-mem
+
+> /plugin install claude-mem
+```
+
+重新啟動 Claude Code。先前工作階段的脈絡將自動出現在新的工作階段中。
+
+**主要功能：**
+
+- 🧠 **持久記憶** - 脈絡跨工作階段保留
+- 📊 **漸進式揭露** - 具有 Token 成本可見性的分層記憶擷取
+- 🔍 **技能式搜尋** - 使用 mem-search 技能查詢專案歷史
+- 🖥️ **網頁檢視介面** - 在 http://localhost:37777 即時檢視記憶串流
+- 💻 **Claude Desktop 技能** - 從 Claude Desktop 對話中搜尋記憶
+- 🔒 **隱私控制** - 使用 `<private>` 標籤排除敏感內容的儲存
+- ⚙️ **脈絡設定** - 精細控制注入哪些脈絡
+- 🤖 **自動運作** - 無需手動介入
+- 🔗 **引用** - 使用 ID 參考過去的觀察（透過 http://localhost:37777/api/observation/{id} 存取，或在 http://localhost:37777 的網頁檢視器中檢視全部）
+- 🧪 **Beta 通道** - 透過版本切換試用 Endless Mode 等實驗性功能
+
+---
+
+## 文件
+
+📚 **[檢視完整文件](docs/)** - 在 GitHub 上瀏覽 Markdown 文件
+
+### 入門指南
+
+- **[安裝指南](https://docs.claude-mem.ai/installation)** - 快速開始與進階安裝
+- **[使用指南](https://docs.claude-mem.ai/usage/getting-started)** - Claude-Mem 如何自動運作
+- **[搜尋工具](https://docs.claude-mem.ai/usage/search-tools)** - 使用自然語言查詢專案歷史
+- **[Beta 功能](https://docs.claude-mem.ai/beta-features)** - 試用 Endless Mode 等實驗性功能
+
+### 最佳實務
+
+- **[脈絡工程](https://docs.claude-mem.ai/context-engineering)** - AI 代理脈絡最佳化原則
+- **[漸進式揭露](https://docs.claude-mem.ai/progressive-disclosure)** - Claude-Mem 脈絡啟動策略背後的理念
+
+### 架構
+
+- **[概覽](https://docs.claude-mem.ai/architecture/overview)** - 系統元件與資料流程
+- **[架構演進](https://docs.claude-mem.ai/architecture-evolution)** - 從 v3 到 v5 的旅程
+- **[Hooks 架構](https://docs.claude-mem.ai/hooks-architecture)** - Claude-Mem 如何使用生命週期掛鉤
+- **[Hooks 參考](https://docs.claude-mem.ai/architecture/hooks)** - 7 個掛鉤腳本說明
+- **[Worker 服務](https://docs.claude-mem.ai/architecture/worker-service)** - HTTP API 與 Bun 管理
+- **[資料庫](https://docs.claude-mem.ai/architecture/database)** - SQLite 結構描述與 FTS5 搜尋
+- **[搜尋架構](https://docs.claude-mem.ai/architecture/search-architecture)** - 使用 Chroma 向量資料庫的混合搜尋
+
+### 設定與開發
+
+- **[設定](https://docs.claude-mem.ai/configuration)** - 環境變數與設定
+- **[開發](https://docs.claude-mem.ai/development)** - 建置、測試、貢獻
+- **[疑難排解](https://docs.claude-mem.ai/troubleshooting)** - 常見問題與解決方案
+
+---
+
+## 運作原理
+
+**核心元件：**
+
+1. **5 個生命週期掛鉤** - SessionStart、UserPromptSubmit、PostToolUse、Stop、SessionEnd（6 個掛鉤腳本）
+2. **智慧安裝** - 快取的相依性檢查器（pre-hook 腳本，非生命週期掛鉤）
+3. **Worker 服務** - 連接埠 37777 上的 HTTP API，含網頁檢視介面與 10 個搜尋端點，由 Bun 管理
+4. **SQLite 資料庫** - 儲存工作階段、觀察、摘要
+5. **mem-search 技能** - 具有漸進式揭露的自然語言查詢
+6. **Chroma 向量資料庫** - 用於智慧脈絡擷取的混合語意 + 關鍵字搜尋
+
+詳情請參閱[架構概覽](https://docs.claude-mem.ai/architecture/overview)。
+
+---
+
+## MCP 搜尋工具
+
+Claude-Mem 透過遵循 Token 高效的 **3 層工作流程模式**，以 **4 個 MCP 工具**提供智慧記憶搜尋：
+
+**3 層工作流程：**
+
+1. **`search`** - 取得精簡索引與 ID（每筆結果約 50-100 tokens）
+2. **`timeline`** - 取得有趣結果周圍的時間脈絡
+3. **`get_observations`** - 僅為過濾後的 ID 擷取完整詳情（每筆結果約 500-1,000 tokens）
+
+**運作方式：**
+
+- Claude 使用 MCP 工具搜尋您的記憶
+- 從 `search` 開始取得結果索引
+- 使用 `timeline` 檢視特定觀察周圍發生的事情
+- 使用 `get_observations` 擷取相關 ID 的完整詳情
+- 透過在擷取詳情前過濾，**節省約 10 倍 token**
+
+**可用的 MCP 工具：**
+
+1. **`search`** - 使用全文查詢搜尋記憶索引，依類型/日期/專案過濾
+2. **`timeline`** - 取得特定觀察或查詢周圍的時間脈絡
+3. **`get_observations`** - 依 ID 擷取完整觀察詳情（批次處理多個 ID）
+4. **`__IMPORTANT`** - 工作流程文件（Claude 永遠可見）
+
+**使用範例：**
+
+```typescript
+// 步驟 1：搜尋索引
+search(query="authentication bug", type="bugfix", limit=10)
+
+// 步驟 2：檢閱索引，識別相關 ID（例如 #123、#456）
+
+// 步驟 3：擷取完整詳情
+get_observations(ids=[123, 456])
+```
+
+詳細範例請參閱[搜尋工具指南](https://docs.claude-mem.ai/usage/search-tools)。
+
+---
+
+## Beta 功能
+
+Claude-Mem 提供具有實驗性功能的 **Beta 通道**，例如 **Endless Mode**（用於延長工作階段的仿生記憶架構）。在 http://localhost:37777 → Settings 的網頁檢視介面中切換穩定版與 Beta 版。
+
+有關 Endless Mode 與如何試用的詳情，請參閱 **[Beta 功能文件](https://docs.claude-mem.ai/beta-features)**。
+
+---
+
+## 系統需求
+
+- **Node.js**：18.0.0 或更高版本
+- **Claude Code**：具有外掛支援的最新版本
+- **Bun**：JavaScript 執行環境與程序管理員（如缺少將自動安裝）
+- **uv**：用於向量搜尋的 Python 套件管理員（如缺少將自動安裝）
+- **SQLite 3**：用於持久儲存（已內建）
+
+---
+
+## 設定
+
+設定在 `~/.claude-mem/settings.json` 中管理（首次執行時自動以預設值建立）。設定 AI 模型、Worker 連接埠、資料目錄、日誌層級與脈絡注入設定。
+
+所有可用設定與範例請參閱 **[設定指南](https://docs.claude-mem.ai/configuration)**。
+
+---
+
+## 開發
+
+建置說明、測試與貢獻工作流程請參閱 **[開發指南](https://docs.claude-mem.ai/development)**。
+
+---
+
+## 疑難排解
+
+如遇問題，向 Claude 描述問題，troubleshoot 技能將自動診斷並提供修正。
+
+常見問題與解決方案請參閱 **[疑難排解指南](https://docs.claude-mem.ai/troubleshooting)**。
+
+---
+
+## 錯誤回報
+
+使用自動產生器建立完整的錯誤回報：
+
+```bash
+cd ~/.claude/plugins/marketplaces/thedotmack
+npm run bug-report
+```
+
+## 貢獻
+
+歡迎貢獻！請依照以下步驟：
+
+1. Fork 儲存庫
+2. 建立功能分支
+3. 加入測試並進行變更
+4. 更新文件
+5. 提交 Pull Request
+
+貢獻工作流程請參閱[開發指南](https://docs.claude-mem.ai/development)。
+
+---
+
+## 授權條款
+
+本專案採用 **GNU Affero 通用公共授權條款 v3.0**（AGPL-3.0）授權。
+
+Copyright (C) 2025 Alex Newman (@thedotmack). All rights reserved.
+
+完整詳情請參閱 [LICENSE](LICENSE) 檔案。
+
+**這代表什麼：**
+
+- 您可以自由使用、修改與散佈此軟體
+- 如果您修改並部署於網路伺服器上，您必須公開您的原始碼
+- 衍生作品也必須採用 AGPL-3.0 授權
+- 本軟體不提供任何擔保
+
+**關於 Ragtime 的說明**：`ragtime/` 目錄採用 **PolyForm Noncommercial License 1.0.0** 另行授權。詳情請參閱 [ragtime/LICENSE](ragtime/LICENSE)。
+
+---
+
+## 支援
+
+- **文件**：[docs/](docs/)
+- **Issues**：[GitHub Issues](https://github.com/thedotmack/claude-mem/issues)
+- **儲存庫**：[github.com/thedotmack/claude-mem](https://github.com/thedotmack/claude-mem)
+- **官方 X 帳號**：[@Claude_Memory](https://x.com/Claude_Memory)
+- **官方 Discord**：[加入 Discord](https://discord.com/invite/J4wttp9vDu)
+- **作者**：Alex Newman ([@thedotmack](https://github.com/thedotmack))
+
+---
+
+**使用 Claude Agent SDK 建置** | **由 Claude Code 驅動** | **以 TypeScript 開發**
@@ -15,6 +15,7 @@

 <p align="center">
  <a href="README.zh.md">🇨🇳 中文</a> •
+  <a href="README.zh-tw.md">🇹🇼 繁體中文</a> •
  <a href="README.ja.md">🇯🇵 日本語</a> •
  <a href="README.pt-br.md">🇧🇷 Português</a> •
  <a href="README.ko.md">🇰🇷 한국어</a> •
@@ -34,6 +35,7 @@
  <a href="README.th.md">🇹🇭 ไทย</a> •
  <a href="README.hi.md">🇮🇳 हिन्दी</a> •
  <a href="README.bn.md">🇧🇩 বাংলা</a> •
+  <a href="README.ur.md">🇵🇰 اردو</a> •
  <a href="README.ro.md">🇷🇴 Română</a> •
  <a href="README.sv.md">🇸🇪 Svenska</a> •
  <a href="README.it.md">🇮🇹 Italiano</a> •
@@ -126,7 +128,7 @@

 ## 文档

-📚 **[查看完整文档](docs/)** - 在 GitHub 上浏览 Markdown 文档
+📚 **[查看完整文档](https://docs.claude-mem.ai/)** - 在官方网站浏览

 ### 入门指南

@@ -212,7 +214,7 @@ Claude-Mem 通过 mem-search 技能提供智能搜索,当您询问过去的工

 Claude-Mem 提供**测试版渠道**,包含实验性功能,如**无尽模式**(用于扩展会话的仿生记忆架构)。从 Web 查看器界面 http://localhost:37777 → 设置 切换稳定版和测试版。

-详见**[测试版功能文档](https://docs.claude-mem.ai/beta-features)**了解无尽模式的详细信息和试用方法。
+详见 **[测试版功能文档](https://docs.claude-mem.ai/beta-features)** 了解无尽模式的详细信息和试用方法。

 ---

@@ -230,13 +232,13 @@ Claude-Mem 提供**测试版渠道**,包含实验性功能,如**无尽模式**(

 设置在 `~/.claude-mem/settings.json` 中管理(首次运行时自动创建默认设置)。可配置 AI 模型、worker 端口、数据目录、日志级别和上下文注入设置。

-详见**[配置指南](https://docs.claude-mem.ai/configuration)**了解所有可用设置和示例。
+详见 **[配置指南](https://docs.claude-mem.ai/configuration)** 了解所有可用设置和示例。

 ---

 ## 开发

-详见**[开发指南](https://docs.claude-mem.ai/development)**了解构建说明、测试和贡献工作流程。
+详见 **[开发指南](https://docs.claude-mem.ai/development)** 了解构建说明、测试和贡献工作流程。

 ---

@@ -244,7 +246,7 @@ Claude-Mem 提供**测试版渠道**,包含实验性功能,如**无尽模式**(

 如果遇到问题,向 Claude 描述问题,troubleshoot 技能将自动诊断并提供修复方案。

-详见**[故障排除指南](https://docs.claude-mem.ai/troubleshooting)**了解常见问题和解决方案。
+详见 **[故障排除指南](https://docs.claude-mem.ai/troubleshooting)** 了解常见问题和解决方案。

 ---

@@ -301,4 +303,4 @@ Copyright (C) 2025 Alex Newman (@thedotmack)。保留所有权利。

 **使用 Claude Agent SDK 构建** | **由 Claude Code 驱动** | **使用 TypeScript 制作**

---
+---
@@ -85,4 +85,4 @@ npx mintlify dev

 **Simple Rule**:
 - `/docs/public/` = Official user documentation (Mintlify .mdx files) ← YOU ARE HERE
- `/docs/context/` = Internal docs, plans, references, audits
+- `/docs/context/` = Internal docs, plans, references, audits
@@ -177,7 +177,7 @@ graph TB

 | Stage | Hook | Trigger | Purpose |
 |-------|------|---------|---------|
-| **1. SessionStart** | `context-hook.js` + `user-message-hook.js` | User opens Claude Code | Inject prior context, show UI messages |
+| **1. SessionStart** | `context-hook.js` | User opens Claude Code | Inject prior context silently |
 | **2. UserPromptSubmit** | `new-hook.js` | User submits a prompt | Create/get session, save prompt, init worker |
 | **3. PostToolUse** | `save-hook.js` | Claude uses any tool | Queue observation for AI compression |
 | **4. Stop** | `summary-hook.js` | User stops asking questions | Generate session summary |
@@ -194,12 +194,16 @@ Hooks are configured in `plugin/hooks/hooks.json`:
      "matcher": "startup|clear|compact",
      "hooks": [{
        "type": "command",
-        "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/context-hook.js",
+        "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/smart-install.js",
        "timeout": 300
      }, {
        "type": "command",
-        "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/user-message-hook.js",
-        "timeout": 10
+        "command": "bun ${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs start",
+        "timeout": 60
+      }, {
+        "type": "command",
+        "command": "bun ${CLAUDE_PLUGIN_ROOT}/scripts/context-hook.js",
+        "timeout": 60
      }]
    }],
    "UserPromptSubmit": [{
@@ -242,8 +246,13 @@ Hooks are configured in `plugin/hooks/hooks.json`:
 **Timing**: When user opens Claude Code or resumes session

 **Hooks Triggered** (in order):
-1. `context-hook.js` - Fetches and injects prior session context
-2. `user-message-hook.js` - Displays context info to user via stderr
+1. `smart-install.js` - Ensures dependencies are installed
+2. `worker-service.cjs start` - Starts the worker service
+3. `context-hook.js` - Fetches and silently injects prior session context
+
+<Note>
+As of Claude Code 2.1.0 (ultrathink update), SessionStart hooks no longer display user-visible messages. Context is silently injected via `hookSpecificOutput.additionalContext`.
+</Note>

 ### Sequence Diagram

@@ -306,19 +315,6 @@ sequenceDiagram

 **Implementation**: `src/hooks/context-hook.ts`

-### User Message Hook (`user-message-hook.js`)
-
-**Purpose**: Display helpful user messages during first-time setup or when viewing context.
-
-**Behavior**:
- Shows first-time setup message when `node_modules` is missing
- Displays formatted context information with colors
- Provides tips for using claude-mem effectively
- Shows link to viewer UI (`http://localhost:37777`)
- Uses stderr as communication channel (only output available in Claude Code UI)
-
-**Implementation**: `src/hooks/user-message-hook.ts`
-
 ---

 ## Stage 2: UserPromptSubmit
@@ -45,19 +45,19 @@ Hook (stdin) → Database → Worker Service → SDK Processor → Database →
 4. **Output**: Processed summaries written back to database
 5. **Retrieval**: Next session's context hook reads summaries from database

-### Search Pipeline (v5.4.0+)
+### Search Pipeline
 ```
-User Query → mem-search Skill Invoked → HTTP API → SessionSearch Service → FTS5 Database → Search Results → Claude
+User Query → MCP Tools Invoked → HTTP API → SessionSearch Service → FTS5 Database → Search Results → Claude
 ```

 1. **User Query**: User asks naturally: "What bugs did we fix?"
-2. **Skill Invoked**: Claude recognizes intent and invokes mem-search skill
-3. **HTTP API**: Skill uses curl to call HTTP endpoint (e.g., `/api/search/observations`)
+2. **MCP Tools Invoked**: Claude recognizes intent and invokes MCP search tools
+3. **HTTP API**: MCP tools call HTTP endpoint (e.g., `/api/search/observations`)
 4. **SessionSearch**: Worker service queries FTS5 virtual tables
-5. **Format**: Results formatted and returned to skill
+5. **Format**: Results formatted and returned via MCP
 6. **Return**: Claude presents formatted results to user

-**Token Savings**: ~2,250 tokens per session vs MCP approach through progressive disclosure
+Uses 3-layer progressive disclosure: search → timeline → get_observations

 ## Session Lifecycle

@@ -18,6 +18,7 @@ Settings are managed in `~/.claude-mem/settings.json`. The file is auto-created
 | `CLAUDE_MEM_MODE`             | `code`                          | Active mode profile (e.g., `code--es`, `email-investigation`) |
 | `CLAUDE_MEM_CONTEXT_OBSERVATIONS` | `50`                        | Number of observations to inject      |
 | `CLAUDE_MEM_WORKER_PORT`      | `37777`                         | Worker service port                   |
+| `CLAUDE_MEM_WORKER_HOST`      | `127.0.0.1`                     | Worker service host address           |
 | `CLAUDE_MEM_SKIP_TOOLS`       | `ListMcpResourcesTool,SlashCommand,Skill,TodoWrite,AskUserQuestion` | Comma-separated tools to exclude from observations |

 ### Gemini Provider Settings
@@ -25,7 +26,7 @@ Settings are managed in `~/.claude-mem/settings.json`. The file is auto-created
 | Setting                       | Default                         | Description                           |
 |-------------------------------|---------------------------------|---------------------------------------|
 | `CLAUDE_MEM_GEMINI_API_KEY`   | —                               | Gemini API key ([get free key](https://aistudio.google.com/app/apikey)) |
-| `CLAUDE_MEM_GEMINI_MODEL`     | `gemini-2.5-flash-lite`          | Gemini model: `gemini-2.5-flash-lite`, `gemini-2.5-flash`, `gemini-3-flash` |
+| `CLAUDE_MEM_GEMINI_MODEL`     | `gemini-2.5-flash-lite`          | Gemini model: `gemini-2.5-flash-lite`, `gemini-2.5-flash`, `gemini-3-flash-preview` |

 See [Gemini Provider](usage/gemini-provider) for detailed configuration and free tier information.

@@ -189,19 +190,16 @@ Hooks are configured in `plugin/hooks/hooks.json`:
 }
 ```

-### Search Configuration (v5.4.0+)
+### Search Configuration

-**Migration Note**: As of v5.4.0, Claude-Mem uses skill-based search instead of MCP tools. As of v5.5.0, the skill was renamed to "mem-search" for better scope differentiation.
+Claude-Mem provides MCP search tools for querying your project history.

-**Previous (v5.3.x and earlier)**: MCP search server with 9 tools (~2,500 tokens per session)
-**Current (v5.4.0+)**: mem-search skill with HTTP API (~250 tokens per session)
+**No configuration required** - MCP tools are automatically available in Claude Code sessions.

-**No configuration required** - the mem-search skill is automatically available in Claude Code sessions.
-
-Search operations are now provided via:
- **Skill**: `plugin/skills/mem-search/SKILL.md` (auto-invoked when users ask about past work)
+Search operations are provided via:
+- **MCP Server**: 3 tools (search, timeline, get_observations) with progressive disclosure
 - **HTTP API**: 10 endpoints on worker service port 37777
- **Progressive Disclosure**: Full instructions loaded on-demand only when needed
+- **Auto-Invocation**: Claude recognizes natural language queries about past work

 ## Version Channel

@@ -229,6 +227,16 @@ Endless Mode is experimental and slower than standard mode. See [Beta Features](

 Worker service is managed by Bun as a background process. The worker auto-starts on first session and runs continuously in the background.

+## Folder Context Files
+
+Claude-mem can automatically generate `CLAUDE.md` files in your project folders with activity timelines. This feature is disabled by default.
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `CLAUDE_MEM_FOLDER_CLAUDEMD_ENABLED` | `false` | Enable auto-generation of folder CLAUDE.md files |
+
+See [Folder Context Files](usage/folder-context) for full documentation on how this feature works, configuration options, and git integration recommendations.
+
 ## Context Injection Configuration

 Claude-Mem injects past observations into each new session, giving Claude awareness of recent work. You can configure exactly what gets injected using the **Context Settings Modal**.
@@ -103,7 +103,7 @@ Open http://localhost:37777 to see the memory viewer.
 |-------|---------------|-------|
 | `gemini-2.5-flash-lite` | 10 (4,000 with billing) | **Default.** Fastest, highest free tier RPM |
 | `gemini-2.5-flash` | 5 (1,000 with billing) | Higher capability |
-| `gemini-3-flash` | 5 (1,000 with billing) | Latest model |
+| `gemini-3-flash-preview` | 5 (1,000 with billing) | Latest model |

 To change the model, update your settings:

@@ -43,6 +43,7 @@
          "usage/private-tags",
          "usage/export-import",
          "usage/manual-recovery",
+          "usage/folder-context",
          "beta-features",
          "endless-mode"
        ]
@@ -72,7 +73,8 @@
          "modes",
          "development",
          "troubleshooting",
-          "platform-integration"
+          "platform-integration",
+          "openclaw-integration"
        ]
      },
      {
@@ -22,11 +22,15 @@ Claude-Mem is fundamentally a **hook-driven system**. Every piece of functionali
 ┌─────────────────────────────────────────────────────────┐
 │                  CLAUDE-MEM SYSTEM                       │
 │                                                          │
-│  Smart      Context     User       New        Obs       │
-│  Install    Inject      Message    Session    Capture   │
+│  Smart      Worker      Context    New        Obs       │
+│  Install    Start       Inject     Session    Capture   │
 └─────────────────────────────────────────────────────────┘
 ```

+<Note>
+As of Claude Code 2.1.0 (ultrathink update), SessionStart hooks no longer display user-visible messages. Context is silently injected via `hookSpecificOutput.additionalContext`.
+</Note>
+
 **Key insight:** Claude-Mem doesn't interrupt or modify Claude Code's behavior. It observes from the outside and provides value through lifecycle hooks.

 ---
@@ -68,9 +72,9 @@ Claude Code's hook system provides exactly what we need:

 ---

-## The Six Hook Scripts + Pre-Hook
+## The Hook Scripts

-Claude-Mem uses 6 lifecycle hook scripts across 5 lifecycle events, plus 1 pre-hook script for dependency management. SessionStart runs 2 hooks in sequence (after the pre-hook script).
+Claude-Mem uses lifecycle hook scripts across 5 lifecycle events. SessionStart runs 3 hooks in sequence: smart-install, worker-service start, and context-hook.

 ### Pre-Hook: Smart Install (Before SessionStart)

@@ -148,63 +152,14 @@ Claude-Mem uses 6 lifecycle hook scripts across 5 lifecycle events, plus 1 pre-h
 |----|------|---|-------|--------|
 | #2586 | 12:58 AM | 🔵 | Context hook file empty | ~51 |

-*Use mem-search skill to access full details*
+*Use MCP search tools to access full details*
 ```

 **Source:** `src/hooks/context-hook.ts` → `plugin/scripts/context-hook.js`

 ---

-### Hook 2: SessionStart - User Message
-
-**Purpose:** Display helpful user messages during first-time setup
-
-**When:** Claude Code starts (runs after context-hook)
-
-**What it does:**
-1. Checks if dependencies are installed
-2. Shows first-time setup message if needed
-3. Displays formatted context information with colors
-4. Shows link to viewer UI (http://localhost:37777)
-5. Exits with code 3 (informational, not error)
-
-**Configuration:**
-```json
-{
-  "hooks": {
-    "SessionStart": [{
-      "matcher": "startup|clear|compact",
-      "hooks": [{
-        "type": "command",
-        "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/user-message-hook.js",
-        "timeout": 10
-      }]
-    }]
-  }
-}
-```
-
-**Output Example:**
-```
-📝 Claude-Mem Context Loaded
-   ℹ️  Note: This appears as stderr but is informational only
-
-[Context details with colors...]
-
-📺 Watch live in browser http://localhost:37777/ (New! v5.1)
-```
-
-**Key Features:**
- ✅ User-friendly first-time experience
- ✅ Visual context display
- ✅ Links to viewer UI
- ✅ Non-intrusive (exit code 3)
-
-**Source:** `plugin/scripts/user-message-hook.js` (minified)
-
---
-
-### Hook 3: UserPromptSubmit (New Session Hook)
+### Hook 2: UserPromptSubmit (New Session Hook)

 **Purpose:** Initialize session tracking when user submits a prompt

@@ -251,7 +206,7 @@ VALUES (?, ?, ?, ...)

 ---

-### Hook 4: PostToolUse (Save Observation Hook)
+### Hook 3: PostToolUse (Save Observation Hook)

 **Purpose:** Capture tool execution observations for later processing

@@ -312,7 +267,7 @@ VALUES (?, ?, ?, ?, ...)

 ---

-### Hook 5: Stop Hook (Summary Generation)
+### Hook 4: Stop Hook (Summary Generation)

 **Purpose:** Generate AI-powered session summaries during the session

@@ -367,7 +322,7 @@ VALUES (?, ?, ?, ?, ...)

 ---

-### Hook 6: SessionEnd (Cleanup Hook)
+### Hook 5: SessionEnd (Cleanup Hook)

 **Purpose:** Mark sessions as completed when they end

@@ -474,14 +429,18 @@ sequenceDiagram

 | Event | Timing | Blocking | Timeout | Output Handling |
 |-------|--------|----------|---------|-----------------|
-| **SessionStart (smart-install)** | Before session | No | 300s | stderr (info) |
-| **SessionStart (context)** | Before session | No | 300s | stdout → context |
-| **SessionStart (user-message)** | Before session | No | 10s | stderr (info) |
-| **UserPromptSubmit** | Before processing | No | 120s | stdout → context |
+| **SessionStart (smart-install)** | Before session | No | 300s | stderr (log only) |
+| **SessionStart (worker-start)** | Before session | No | 60s | stderr (log only) |
+| **SessionStart (context)** | Before session | No | 60s | JSON → additionalContext (silent) |
+| **UserPromptSubmit** | Before processing | No | 60s | stdout → context |
 | **PostToolUse** | After tool | No | 120s | Transcript only |
 | **Summary** | Worker triggered | No | 120s | Database |
 | **SessionEnd** | On exit | No | 120s | Log only |

+<Note>
+As of Claude Code 2.1.0 (ultrathink update), SessionStart hooks no longer display user-visible messages. Context is silently injected via `hookSpecificOutput.additionalContext`.
+</Note>
+
 ---

 ## The Worker Service Architecture
@@ -23,15 +23,16 @@ Restart Claude Code. Context from previous sessions will automatically appear in
 ## Key Features

 - 🧠 **Persistent Memory** - Context survives across sessions
- 🌐 **Multilingual Modes** - Supports 10+ languages (Spanish, Chinese, French, etc.)
- 🎭 **Mode System** - Switch between workflows (Code, Email Investigation)
- 🔍 **mem-search Skill** - Query your project history with natural language (~2,250 token savings)
+- 📁 **Folder Context Files** - Auto-generated `CLAUDE.md` in project folders with activity timelines
+- 🌐 **Multilingual Modes** - Supports 28 languages (Spanish, Chinese, French, Japanese, etc.)
+- 🎭 **Mode System** - Switch between workflows (Code, Email Investigation, Chill)
+- 🔍 **MCP Search Tools** - Query your project history with natural language
 - 🌐 **Web Viewer UI** - Real-time memory stream visualization at http://localhost:37777
 - 🔒 **Privacy Control** - Use `<private>` tags to exclude sensitive content from storage
 - ⚙️ **Context Configuration** - Fine-grained control over what context gets injected
 - 🤖 **Automatic Operation** - No manual intervention required
 - 📊 **FTS5 Search** - Fast full-text search across observations
- 🔗 **Citations** - Reference past observations with IDs (access via http://localhost:37777/api/observation/{id} or view all in the web viewer at http://localhost:37777)
+- 🔗 **Citations** - Reference past observations with IDs

 ## How It Works

@@ -58,11 +59,11 @@ Restart Claude Code. Context from previous sessions will automatically appear in
 ```

 **Core Components:**
-1. **5 Lifecycle Hooks** - SessionStart, UserPromptSubmit, PostToolUse, Stop, SessionEnd (6 hook scripts)
+1. **4 Lifecycle Hooks** - SessionStart, UserPromptSubmit, PostToolUse, Stop
 2. **Smart Install** - Cached dependency checker (pre-hook script)
 3. **Worker Service** - HTTP API on port 37777 managed by Bun
 4. **SQLite Database** - Stores sessions, observations, summaries with FTS5 search
-5. **mem-search Skill** - Query historical context with natural language
+5. **MCP Search Tools** - Query historical context with natural language
 6. **Web Viewer UI** - Real-time visualization with SSE and infinite scroll

 See [Architecture Overview](architecture/overview) for details.
@@ -76,21 +77,23 @@ See [Architecture Overview](architecture/overview) for details.

 ## What's New

+**v9.0.0 - Live Context:**
+- **Folder Context Files**: Auto-generated `CLAUDE.md` in project folders with activity timelines
+- **Worktree Support**: Unified context from parent repos and git worktrees
+- **Configurable Observation Limits**: Control how many observations appear in context
+- **Windows Fixes**: Resolved IPC detection and hook execution issues
+- **Settings Auto-Creation**: `settings.json` now auto-creates on first run
+- **MCP Tools Naming**: Updated from "mem-search skill" to "MCP tools" terminology
+
 **v7.1.0 - Bun Migration:**
 - Replaced PM2 with native Bun process management
 - Switched from better-sqlite3 to bun:sqlite for faster database access
- Automatic one-time migration on first hook trigger
 - Simplified cross-platform support

 **v7.0.0 - Context Configuration:**
 - 11 settings for fine-grained control over context injection
 - Dual-tag privacy system (`<private>` tags)

-**Previous Highlights:**
- **v5.5.0**: mem-search skill with 100% effectiveness rate
- **v5.4.0**: Skill-based search (~2,250 tokens saved per session)
- **v5.1.0**: Web viewer UI at http://localhost:37777
-
 ## Next Steps

 <CardGroup cols={2}>
@@ -100,8 +103,8 @@ See [Architecture Overview](architecture/overview) for details.
  <Card title="Getting Started" icon="rocket" href="/usage/getting-started">
    Learn how Claude-Mem works automatically
  </Card>
-  <Card title="Architecture" icon="sitemap" href="/architecture/overview">
-    System components & data flow
+  <Card title="Folder Context" icon="folder-open" href="/usage/folder-context">
+    Auto-generated folder CLAUDE.md files
  </Card>
  <Card title="Search Tools" icon="magnifying-glass" href="/usage/search-tools">
    Query your project history
@@ -65,6 +65,7 @@ Inherits all behavior from Code Mode but instructs Claude to generate **all** me
 | **Hindi** | `code--hi` | हिन्दी |
 | **Hungarian** | `code--hu` | Magyar |
 | **Indonesian** | `code--id` | Bahasa Indonesia |
+| **Urdu** | `code--ur` | اردو |
 | **Italian** | `code--it` | Italiano |
 | **Japanese** | `code--ja` | 日本語 |
 | **Korean** | `code--ko` | 한국어 |
@@ -0,0 +1,362 @@
+---
+title: OpenClaw Integration
+description: Persistent memory for OpenClaw agents — observation recording, MEMORY.md live sync, and real-time observation feeds
+icon: dragon
+---
+
+## Overview
+
+The OpenClaw plugin gives claude-mem persistent memory to agents running on the [OpenClaw](https://openclaw.ai) gateway. It handles three things:
+
+1. **Observation recording** — Captures tool usage from OpenClaw's embedded runner and sends it to the claude-mem worker for AI processing
+2. **MEMORY.md live sync** — Writes a continuously-updated timeline to each agent's workspace so agents always have context from previous sessions
+3. **Observation feed** — Streams new observations to messaging channels (Telegram, Discord, Slack, etc.) in real-time via SSE
+
+<Info>
+OpenClaw's embedded runner (`pi-embedded`) calls the Anthropic API directly without spawning a `claude` process, so claude-mem's standard hooks never fire. This plugin bridges that gap by using OpenClaw's event system to capture the same data.
+</Info>
+
+## How It Works
+
+```plaintext
+OpenClaw Gateway
+  │
+  ├── before_agent_start ──→ Sync MEMORY.md + Init session
+  ├── tool_result_persist ──→ Record observation + Re-sync MEMORY.md
+  ├── agent_end ────────────→ Summarize + Complete session
+  └── gateway_start ────────→ Reset session tracking
+                    │
+                    ▼
+         Claude-Mem Worker (localhost:37777)
+           ├── POST /api/sessions/init
+           ├── POST /api/sessions/observations
+           ├── POST /api/sessions/summarize
+           ├── POST /api/sessions/complete
+           ├── GET  /api/context/inject ──→ MEMORY.md content
+           └── GET  /stream ─────────────→ SSE → Messaging channels
+```
+
+### Event Lifecycle
+
+<Steps>
+  <Step title="Agent starts (before_agent_start)">
+    When an OpenClaw agent starts, the plugin does two things:
+
+    1. **Syncs MEMORY.md** — Fetches the latest timeline from the worker's `/api/context/inject` endpoint and writes it to `MEMORY.md` in the agent's workspace directory. This gives the agent context from all previous sessions before it starts working.
+
+    2. **Initializes a session** — Sends the user prompt to `POST /api/sessions/init` so the worker can create a new session and start processing.
+
+    Short prompts (under 10 characters) skip session init but still sync MEMORY.md.
+  </Step>
+  <Step title="Tool use recorded (tool_result_persist)">
+    Every time the agent uses a tool (Read, Write, Bash, etc.), the plugin:
+
+    1. **Sends the observation** to `POST /api/sessions/observations` with the tool name, input, and truncated response (max 1000 chars)
+    2. **Re-syncs MEMORY.md** with the latest timeline from the worker
+
+    Both operations are fire-and-forget — they don't block the agent from continuing work. The MEMORY.md file gets progressively richer as the session continues.
+
+    Tools prefixed with `memory_` are skipped to avoid recursive recording.
+  </Step>
+  <Step title="Agent finishes (agent_end)">
+    When the agent completes, the plugin extracts the last assistant message and sends it to `POST /api/sessions/summarize`, then calls `POST /api/sessions/complete` to close the session. Both are fire-and-forget.
+  </Step>
+  <Step title="Gateway restarts (gateway_start)">
+    Clears all session tracking (session IDs, workspace directory mappings) so agents get fresh state after a gateway restart.
+  </Step>
+</Steps>
+
+### MEMORY.md Live Sync
+
+The plugin writes a `MEMORY.md` file to each agent's workspace directory containing the full timeline of observations and summaries from previous sessions. This file is updated:
+
+- On every `before_agent_start` event (agent gets fresh context before starting)
+- On every `tool_result_persist` event (context stays current during the session)
+
+The content comes from the worker's `GET /api/context/inject?projects=<project>` endpoint, which generates a formatted markdown timeline from the SQLite database.
+
+<Info>
+MEMORY.md updates are fire-and-forget. They run in the background without blocking the agent. The file reflects whatever the worker has processed so far — it doesn't wait for the current observation to be fully processed before writing.
+</Info>
+
+### Observation Feed (SSE → Messaging)
+
+The plugin runs a background service that connects to the worker's SSE stream (`GET /stream`) and forwards `new_observation` events to a configured messaging channel. This lets you monitor what your agents are learning in real-time from Telegram, Discord, Slack, or any supported OpenClaw channel.
+
+The SSE connection uses exponential backoff (1s → 30s) for automatic reconnection.
+
+## Setting Up the Observation Feed
+
+The observation feed sends a formatted message to your OpenClaw channel every time claude-mem creates a new observation. Each message includes the observation title and subtitle so you can follow along as your agents work.
+
+Messages look like this in your channel:
+
+```
+🧠 Claude-Mem Observation
+**Implemented retry logic for API client**
+Added exponential backoff with configurable max retries to handle transient failures
+```
+
+### Step 1: Choose your channel
+
+The observation feed works with any channel that your OpenClaw gateway has configured. You need two pieces of information:
+
+- **Channel type** — The name of the channel plugin registered with OpenClaw (e.g., `telegram`, `discord`, `slack`, `signal`, `whatsapp`, `line`)
+- **Target ID** — The chat ID, channel ID, or user ID where messages should be sent
+
+<AccordionGroup>
+  <Accordion title="Telegram" icon="telegram">
+    **Channel type:** `telegram`
+
+    **Target ID:** Your Telegram chat ID (numeric). To find it:
+    1. Message [@userinfobot](https://t.me/userinfobot) on Telegram
+    2. It will reply with your chat ID (e.g., `123456789`)
+    3. For group chats, the ID is negative (e.g., `-1001234567890`)
+
+    ```json
+    "observationFeed": {
+      "enabled": true,
+      "channel": "telegram",
+      "to": "123456789"
+    }
+    ```
+  </Accordion>
+
+  <Accordion title="Discord" icon="discord">
+    **Channel type:** `discord`
+
+    **Target ID:** The Discord channel ID. To find it:
+    1. Enable Developer Mode in Discord (Settings → Advanced → Developer Mode)
+    2. Right-click the channel → Copy Channel ID
+
+    ```json
+    "observationFeed": {
+      "enabled": true,
+      "channel": "discord",
+      "to": "1234567890123456789"
+    }
+    ```
+  </Accordion>
+
+  <Accordion title="Slack" icon="slack">
+    **Channel type:** `slack`
+
+    **Target ID:** The Slack channel ID (not the channel name). To find it:
+    1. Open the channel in Slack
+    2. Click the channel name at the top
+    3. Scroll to the bottom of the channel details — the ID looks like `C01ABC2DEFG`
+
+    ```json
+    "observationFeed": {
+      "enabled": true,
+      "channel": "slack",
+      "to": "C01ABC2DEFG"
+    }
+    ```
+  </Accordion>
+
+  <Accordion title="Signal" icon="signal-messenger">
+    **Channel type:** `signal`
+
+    **Target ID:** The Signal phone number or group ID configured in your OpenClaw gateway.
+
+    ```json
+    "observationFeed": {
+      "enabled": true,
+      "channel": "signal",
+      "to": "+1234567890"
+    }
+    ```
+  </Accordion>
+
+  <Accordion title="WhatsApp" icon="whatsapp">
+    **Channel type:** `whatsapp`
+
+    **Target ID:** The WhatsApp phone number or group JID configured in your OpenClaw gateway.
+
+    ```json
+    "observationFeed": {
+      "enabled": true,
+      "channel": "whatsapp",
+      "to": "+1234567890"
+    }
+    ```
+  </Accordion>
+
+  <Accordion title="LINE" icon="line">
+    **Channel type:** `line`
+
+    **Target ID:** The LINE user ID or group ID from the LINE Developer Console.
+
+    ```json
+    "observationFeed": {
+      "enabled": true,
+      "channel": "line",
+      "to": "U1234567890abcdef"
+    }
+    ```
+  </Accordion>
+</AccordionGroup>
+
+### Step 2: Add the config to your gateway
+
+Add the `observationFeed` block to your claude-mem plugin config in your OpenClaw gateway configuration:
+
+```json
+{
+  "plugins": {
+    "claude-mem": {
+      "enabled": true,
+      "config": {
+        "project": "my-project",
+        "observationFeed": {
+          "enabled": true,
+          "channel": "telegram",
+          "to": "123456789"
+        }
+      }
+    }
+  }
+}
+```
+
+<Warning>
+The `channel` value must match a channel plugin that is already configured and running on your OpenClaw gateway. If the channel isn't registered, you'll see `Unknown channel type: <channel>` in the logs.
+</Warning>
+
+### Step 3: Verify the connection
+
+After starting the gateway, check that the feed is connected:
+
+1. **Check the logs** — You should see:
+   ```
+   [claude-mem] Observation feed starting — channel: telegram, target: 123456789
+   [claude-mem] Connecting to SSE stream at http://localhost:37777/stream
+   [claude-mem] Connected to SSE stream
+   ```
+
+2. **Use the status command** — Run `/claude-mem-feed` in any OpenClaw chat to see:
+   ```
+   Claude-Mem Observation Feed
+   Enabled: yes
+   Channel: telegram
+   Target: 123456789
+   Connection: connected
+   ```
+
+3. **Trigger a test** — Have an agent do some work. When the worker processes the tool usage into an observation, you'll receive a message in your configured channel.
+
+<Info>
+The feed only sends `new_observation` events — not raw tool usage. Observations are generated asynchronously by the worker's AI agent, so there's a 1-2 second delay between tool use and the observation message appearing in your channel.
+</Info>
+
+### Troubleshooting the Feed
+
+| Symptom | Cause | Fix |
+|---------|-------|-----|
+| `Connection: disconnected` | Worker not running or wrong port | Check `workerPort` config, run `npm run worker:status` |
+| `Connection: reconnecting` | Worker was running but connection dropped | The plugin auto-reconnects with backoff — wait up to 30s |
+| `Unknown channel type` in logs | Channel plugin not loaded on gateway | Verify your OpenClaw gateway has the channel plugin configured |
+| No messages appearing | Feed connected but no observations being created | Check that agents are running and the worker is processing observations |
+| `Observation feed disabled` in logs | `enabled` is `false` or missing | Set `observationFeed.enabled` to `true` |
+| `Observation feed misconfigured` in logs | Missing `channel` or `to` | Both `channel` and `to` are required |
+
+## Installation
+
+Add `claude-mem` to your OpenClaw gateway's plugin configuration:
+
+```json
+{
+  "plugins": {
+    "claude-mem": {
+      "enabled": true,
+      "config": {
+        "project": "my-project",
+        "syncMemoryFile": true,
+        "workerPort": 37777,
+        "observationFeed": {
+          "enabled": true,
+          "channel": "telegram",
+          "to": "your-chat-id"
+        }
+      }
+    }
+  }
+}
+```
+
+<Note>
+The claude-mem worker service must be running on the same machine as the OpenClaw gateway. The plugin communicates with it via HTTP on `localhost:37777`.
+</Note>
+
+## Configuration
+
+<ParamField body="project" type="string" default="openclaw">
+  Project name for scoping observations in the memory database. All observations from this gateway will be stored under this project name.
+</ParamField>
+
+<ParamField body="syncMemoryFile" type="boolean" default={true}>
+  Enable automatic MEMORY.md sync to agent workspaces. Set to `false` if you don't want the plugin writing files to workspace directories.
+</ParamField>
+
+<ParamField body="workerPort" type="number" default={37777}>
+  Port for the claude-mem worker service. Override if your worker runs on a non-default port.
+</ParamField>
+
+<ParamField body="observationFeed.enabled" type="boolean" default={false}>
+  Enable live observation streaming to messaging channels.
+</ParamField>
+
+<ParamField body="observationFeed.channel" type="string">
+  Channel type: `telegram`, `discord`, `signal`, `slack`, `whatsapp`, `line`
+</ParamField>
+
+<ParamField body="observationFeed.to" type="string">
+  Target chat/user/channel ID to send observations to.
+</ParamField>
+
+## Commands
+
+### /claude-mem-feed
+
+Show or toggle the observation feed status.
+
+```
+/claude-mem-feed        # Show current status
+/claude-mem-feed on     # Request enable
+/claude-mem-feed off    # Request disable
+```
+
+### /claude-mem-status
+
+Check worker health and session status.
+
+```
+/claude-mem-status
+```
+
+Returns worker status, port, active session count, and observation feed connection state.
+
+## Architecture
+
+The plugin uses HTTP calls to the already-running claude-mem worker service rather than spawning subprocesses. This means:
+
+- No `bun` dependency required on the gateway
+- No process spawn overhead per event
+- Uses the same worker API that Claude Code hooks use
+- All operations are non-blocking (fire-and-forget where possible)
+
+### Session Tracking
+
+Each OpenClaw agent session gets a unique `contentSessionId` (format: `openclaw-<sessionKey>-<timestamp>`) that maps to a claude-mem session in the worker. The plugin tracks:
+
+- `sessionIds` — Maps OpenClaw session keys to content session IDs
+- `workspaceDirsBySessionKey` — Maps session keys to workspace directories so `tool_result_persist` events can sync MEMORY.md even when the event context doesn't include `workspaceDir`
+
+Both maps are cleared on `gateway_start`.
+
+## Requirements
+
+- Claude-mem worker service running on `localhost:37777` (or configured port)
+- OpenClaw gateway with plugin support
+- Network access between gateway and worker (localhost only)
@@ -1,23 +1,23 @@
 ---
-title: Claude Desktop Skill
-description: Use claude-mem memory search in Claude Desktop with the mem-search skill
+title: Claude Desktop MCP
+description: Use claude-mem memory search in Claude Desktop with MCP tools
 icon: desktop
 ---

 <Note>
-**Availability:** The mem-search skill works with Claude Desktop on macOS and Windows.
+**Availability:** Claude-mem MCP tools work with Claude Desktop on macOS and Windows.
 </Note>

 ## Overview

-Claude Desktop can access your claude-mem memory database through the **mem-search** skill. This allows you to search past sessions, decisions, and observations directly from Claude Desktop conversations.
+Claude Desktop can access your claude-mem memory database through **MCP tools**. This allows you to search past sessions, decisions, and observations directly from Claude Desktop conversations.

 ## Prerequisites

-Before installing the skill, ensure:
+Before configuring MCP tools, ensure:

 1. **claude-mem is installed** and the worker service is running
-2. **MCP server is configured** in Claude Desktop (the skill uses the `mcp-search` MCP server)
+2. **MCP server is configured** in Claude Desktop (uses the `mcp-search` MCP server)

 ### Verify Worker is Running

@@ -0,0 +1,280 @@
+---
+title: "Folder Context Files"
+description: "Automatic per-folder CLAUDE.md files that provide directory-level context to Claude"
+---
+
+## Overview
+
+Claude-mem automatically generates `CLAUDE.md` files in your project folders to provide Claude with directory-level context. These files contain a summary of recent activity in each folder, helping Claude understand what work has been done and where.
+
+<Info>
+This feature is **disabled by default**. Enable it via settings if you want automatic folder-level context generation.
+</Info>
+
+## How It Works
+
+When you work with Claude Code in a project, claude-mem tracks which files are read and modified. After each observation is saved, it automatically:
+
+1. Identifies unique folder paths from touched files
+2. Queries recent observations relevant to each folder
+3. Generates a formatted timeline of activity
+4. Writes it to `CLAUDE.md` in that folder (inside `<claude-mem-context>` tags)
+
+### What Gets Generated
+
+Each folder's `CLAUDE.md` contains a "Recent Activity" section showing:
+
+- Observation IDs for reference
+- Timestamps of when work occurred
+- Type indicators (bug fixes, features, discoveries, etc.)
+- Brief titles describing the work
+- Estimated token counts
+
+```markdown
+<claude-mem-context>
+# Recent Activity
+
+<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
+
+### Jan 4, 2026
+
+| ID | Time | T | Title | Read |
+|----|------|---|-------|------|
+| #1234 | 4:30 PM | 🔵 | Implemented user authentication | ~250 |
+| #1235 | " | 🔴 | Fixed login redirect bug | ~180 |
+</claude-mem-context>
+```
+
+### User Content Preservation
+
+The auto-generated content is wrapped in `<claude-mem-context>` tags. **Any content you write outside these tags is preserved** when the file is regenerated. This means you can:
+
+- Add your own documentation above or below the generated section
+- Write folder-specific instructions for Claude
+- Include architectural notes or conventions
+
+```markdown
+# Authentication Module
+
+This folder contains all authentication-related code.
+Follow the established patterns for new auth providers.
+
+<claude-mem-context>
+... auto-generated content ...
+</claude-mem-context>
+
+## Manual Notes
+
+- OAuth providers go in /providers/
+- Session handling uses Redis
+```
+
+### Project Root Exclusion
+
+The **project root** (folders containing a `.git` directory) is **excluded** from auto-generation. This is intentional:
+
+- Root `CLAUDE.md` files typically contain project-wide instructions you've written manually
+- Auto-generating at the root could overwrite important project documentation
+- Subfolders are where folder-level context is most useful
+
+<Note>
+Git submodules (which have a `.git` *file* instead of directory) are correctly detected and **not** excluded, so they receive auto-generated context.
+</Note>
+
+## Configuration
+
+### Enabling the Feature
+
+To enable folder CLAUDE.md generation, edit your settings file:
+
+**1. Open `~/.claude-mem/settings.json`**
+
+**2. Add or update this setting:**
+```json
+{
+  "CLAUDE_MEM_FOLDER_CLAUDEMD_ENABLED": "true"
+}
+```
+
+**3. Save the file** - changes take effect immediately (no restart needed)
+
+| Value | Behavior |
+|-------|----------|
+| `"false"` (default) | Folder CLAUDE.md generation disabled |
+| `"true"` | Auto-generate folder CLAUDE.md files |
+
+<Tip>
+If the settings file doesn't exist, create it with just the settings you want to change. Claude-mem will use defaults for any missing settings.
+</Tip>
+
+## Cleanup Mode
+
+The regenerate script includes a `--clean` mode for removing auto-generated content:
+
+```bash
+# Preview what would be cleaned (dry run)
+bun scripts/regenerate-claude-md.ts --clean --dry-run
+
+# Actually clean files
+bun scripts/regenerate-claude-md.ts --clean
+```
+
+**What cleanup does:**
+1. Finds all `CLAUDE.md` files recursively
+2. Strips `<claude-mem-context>...</claude-mem-context>` sections
+3. **Deletes** files that become empty after stripping
+4. **Preserves** files that have user content outside the tags
+
+This is useful for:
+- Preparing a branch for PR (removing generated files)
+- Resetting folder context to start fresh
+- Removing context before sharing code
+
+## Git Integration
+
+### Should You Commit These Files?
+
+This is **your choice** based on your workflow. Here are the trade-offs:
+
+<Tabs>
+  <Tab title="Commit Them">
+    **Pros:**
+    - Team members see folder-level context and recent activity
+    - New contributors can understand what happened where
+    - Code reviewers get additional context about changes
+    - Historical record of work patterns in the repo
+
+    **Cons:**
+    - Adds files to your repository
+    - Files change frequently during development
+    - May create noise in diffs and commit history
+    - Different team members may generate different content
+  </Tab>
+  <Tab title="Gitignore Them">
+    **Pros:**
+    - Clean repository without generated files
+    - No commit noise from auto-generated content
+    - Each developer has their own local context
+    - Simpler git history
+
+    **Cons:**
+    - Team doesn't share folder context
+    - Context is lost when switching machines
+    - New team members don't benefit from existing context
+  </Tab>
+</Tabs>
+
+### Gitignore Pattern
+
+To exclude folder CLAUDE.md files from git:
+
+```gitignore
+# Ignore auto-generated folder context files
+**/CLAUDE.md
+
+# But keep the root CLAUDE.md if you want
+!CLAUDE.md
+```
+
+Or to ignore all CLAUDE.md files everywhere:
+```gitignore
+**/CLAUDE.md
+```
+
+### Recommended Workflows
+
+**For Solo Developers:**
+- Keep them local (gitignore) for personal context
+- Or commit them if you work across multiple machines
+
+**For Teams:**
+- Discuss with your team which approach works best
+- Consider committing them if onboarding is frequent
+- Use `--clean` before PRs if you prefer clean diffs
+
+**Before Merging PRs:**
+```bash
+# Clean up generated files before merge
+bun scripts/regenerate-claude-md.ts --clean
+git add -A
+git commit -m "chore: clean up generated CLAUDE.md files"
+```
+
+## Regenerating Context
+
+To manually regenerate all folder CLAUDE.md files from the database:
+
+```bash
+# Preview what would be regenerated
+bun scripts/regenerate-claude-md.ts --dry-run
+
+# Regenerate all folders
+bun scripts/regenerate-claude-md.ts
+
+# Regenerate for a specific project only
+bun scripts/regenerate-claude-md.ts --project=my-project
+```
+
+This is useful after:
+- Importing observations from another machine
+- Database recovery
+- Wanting to refresh all folder context
+
+## Worktree Support
+
+**New in v9.0**: Claude-mem now supports git worktrees with unified context.
+
+When you're working in a git worktree, context is automatically gathered from both:
+- The parent repository (where the worktree was created)
+- The worktree directory itself
+
+This means observations about shared code are visible regardless of which worktree you're in, giving you a complete picture of recent activity across all related directories.
+
+### How It Works
+
+1. When generating context, claude-mem detects if your project is a worktree
+2. It identifies the parent repository automatically
+3. Timeline queries include both locations
+4. Results are interleaved chronologically
+
+<Note>
+No configuration needed - worktree detection is automatic. If you're not using worktrees, this feature has no effect.
+</Note>
+
+## Technical Details
+
+### File Format
+
+Generated content uses a consistent markdown table format:
+
+| Column | Description |
+|--------|-------------|
+| ID | Observation ID (e.g., `#1234`) or session ID (`#S123`) |
+| Time | 12-hour format with AM/PM, ditto marks (`"`) for repeated times |
+| T | Type emoji indicator |
+| Title | Brief description of the observation |
+| Read | Estimated token count (e.g., `~250`) |
+
+### Type Indicators
+
+| Emoji | Type |
+|-------|------|
+| 🔴 | Bug fix |
+| 🟣 | Feature |
+| 🔄 | Refactor |
+| ✅ | Change |
+| 🔵 | Discovery |
+| ⚖️ | Decision |
+| 🎯 | Session |
+| 💬 | Prompt |
+
+### Atomic Writes
+
+Files are written atomically using a temp file + rename pattern. This prevents partial writes if the process is interrupted.
+
+### Performance
+
+- Updates happen asynchronously (fire-and-forget)
+- Failures are logged but don't block the main workflow
+- Only folders with actual file activity are updated
+- Deduplication prevents redundant updates for the same folder
@@ -39,7 +39,7 @@ Claude-mem supports Google's Gemini API as an alternative to the Claude Agent SD
 |---------|--------|---------|-------------|
 | `CLAUDE_MEM_PROVIDER` | `claude`, `gemini` | `claude` | AI provider for observation extraction |
 | `CLAUDE_MEM_GEMINI_API_KEY` | string | — | Your Gemini API key |
-| `CLAUDE_MEM_GEMINI_MODEL` | `gemini-2.5-flash-lite`, `gemini-2.5-flash`, `gemini-3-flash` | `gemini-2.5-flash-lite` | Gemini model to use |
+| `CLAUDE_MEM_GEMINI_MODEL` | `gemini-2.5-flash-lite`, `gemini-2.5-flash`, `gemini-3-flash-preview` | `gemini-2.5-flash-lite` | Gemini model to use |
 | `CLAUDE_MEM_GEMINI_BILLING_ENABLED` | `true`, `false` | `false` | Skip rate limiting if billing is enabled on Google Cloud |

 ### Using the Settings UI
@@ -79,7 +79,7 @@ The settings file takes precedence over the environment variable.
 |-------|--------------|-------|
 | `gemini-2.5-flash-lite` | 10 | Default, recommended for free tier (highest RPM) |
 | `gemini-2.5-flash` | 5 | Higher capability, lower rate limit |
-| `gemini-3-flash` | 5 | Latest model, lower rate limit |
+| `gemini-3-flash-preview` | 5 | Latest model, lower rate limit |

 ## Provider Switching

@@ -139,7 +139,7 @@ Google has two rate limit tiers for free usage:
 |-------|-----|-----|
 | gemini-2.5-flash-lite | 10 | 250K |
 | gemini-2.5-flash | 5 | 250K |
-| gemini-3-flash | 5 | 250K |
+| gemini-3-flash-preview | 5 | 250K |

 Claude-mem enforces these limits automatically with built-in delays between requests. Processing may be slower but stays within limits.

@@ -149,7 +149,7 @@ Claude-mem enforces these limits automatically with built-in delays between requ
 |-------|-----|-----|
 | gemini-2.5-flash-lite | 4,000 | 4M |
 | gemini-2.5-flash | 1,000 | 1M |
-| gemini-3-flash | 1,000 | 1M |
+| gemini-3-flash-preview | 1,000 | 1M |

 <Tip>
 **Recommended**: Enable billing on your Google Cloud project to unlock much higher rate limits. You won't be charged unless you exceed the generous free quota. This allows claude-mem to process observations instantly instead of waiting between requests.
@@ -160,13 +160,13 @@ Context injection uses progressive disclosure for efficient token usage:
 - Shows full summary details **only if** generated after last observation
 - Token cost: ~50-200 tokens for index view

-### Layer 2: On-Demand Details (mem-search Skill)
+### Layer 2: On-Demand Details (MCP Tools)
 - Ask naturally: "What bugs did we fix?" or "How did we implement X?"
- Claude auto-invokes mem-search skill to fetch full details
+- Claude auto-invokes MCP search tools to fetch full details
 - Search by concept, file, type, or keyword
 - Timeline context around specific observations
 - Token cost: ~100-500 tokens per observation fetched
- Skill uses HTTP API (v5.4.0+) for efficient retrieval
+- Uses 3-layer workflow: search → timeline → get_observations

 ### Layer 3: Perfect Recall (Code Access)
 - Read source files directly when needed
@@ -193,9 +193,9 @@ When you use `/clear`, the session doesn't end - it continues with a new prompt

 The `/clear` command clears the conversation context visible to Claude AND re-injects fresh context from recent sessions, while the underlying session continues tracking observations.

-## Searching Your History (v5.4.0+)
+## Searching Your History

-Claude-Mem uses the mem-search skill for querying your project history. Simply ask naturally:
+Claude-Mem provides MCP tools for querying your project history. Simply ask naturally:

 ```
 "What bugs did we fix last session?"
@@ -204,9 +204,7 @@ Claude-Mem uses the mem-search skill for querying your project history. Simply a
 "Show me recent work on this project"
 ```

-Claude automatically recognizes your intent and invokes the mem-search skill, which uses HTTP API endpoints to query your memory efficiently.
-
-**Token Savings**: ~2,250 tokens per session start vs previous MCP approach
+Claude automatically recognizes your intent and invokes the MCP search tools, which use a 3-layer workflow (search → timeline → get_observations) for efficient token usage.

 ## Next Steps

@@ -0,0 +1,70 @@
+# Issue #511: GeminiAgent Missing gemini-3-flash Model
+
+## Summary
+
+**Issue**: `gemini-3-flash` model missing from GeminiAgent validation
+**Type**: Bug - Configuration Mismatch
+**Status**: Open
+
+The `GeminiAgent` class is missing `gemini-3-flash` in its `validModels` array and `GeminiModel` type, while `SettingsRoutes` correctly validates it. This causes a silent fallback to `gemini-2.5-flash` when users configure `gemini-3-flash`.
+
+## Root Cause
+
+Synchronization gap between two configuration validation sources:
+
+| Component | Location | Status |
+|-----------|----------|--------|
+| SettingsRoutes.ts (line 244) | Settings validation | Includes `gemini-3-flash` |
+| GeminiAgent.ts (lines 34-39) | Type definition | **MISSING** |
+| GeminiAgent.ts (lines 42-48) | RPM limits | **MISSING** |
+| GeminiAgent.ts (lines 370-376) | validModels array | **MISSING** |
+
+## Failure Behavior
+
+1. User configures `gemini-3-flash` in settings
+2. Settings validation passes (SettingsRoutes.ts includes it)
+3. At runtime, `GeminiAgent.getGeminiConfig()`:
+   - Checks `validModels` - model not found
+   - Logs warning: "Invalid Gemini model 'gemini-3-flash', falling back to gemini-2.5-flash"
+   - Silently uses wrong model
+
+## Affected Files
+
+| File | Change Required |
+|------|-----------------|
+| `src/services/worker/GeminiAgent.ts` | Add to type, RPM limits, validModels |
+
+## Recommended Fix
+
+**3 additions to GeminiAgent.ts:**
+
+```typescript
+// 1. Type definition (lines 34-39)
+export type GeminiModel =
+  | 'gemini-2.5-flash-lite'
+  | 'gemini-2.5-flash'
+  | 'gemini-2.5-pro'
+  | 'gemini-2.0-flash'
+  | 'gemini-2.0-flash-lite'
+  | 'gemini-3-flash';  // ADD
+
+// 2. RPM limits (lines 42-48)
+const GEMINI_RPM_LIMITS: Record<GeminiModel, number> = {
+  // ... existing entries ...
+  'gemini-3-flash': 5,  // ADD
+};
+
+// 3. validModels (lines 370-376)
+const validModels: GeminiModel[] = [
+  // ... existing entries ...
+  'gemini-3-flash',  // ADD
+];
+```
+
+## Complexity
+
+**Trivial** - < 5 minutes
+
+- 3 lines to add in 1 file
+- No test changes required
+- Fully backward compatible
@@ -0,0 +1,292 @@
+# Issue #514: Orphaned Observer Session Files Analysis
+
+**Date:** January 4, 2026
+**Status:** PARTIALLY RESOLVED - Root cause understood, fix was made but reverted
+**Original Issue:** 13,000+ orphaned .jsonl session files created over 2 days
+
+---
+
+## Executive Summary
+
+Issue #514 reported that the plugin created 13,000+ orphaned session .jsonl files in `~/.claude/projects/<project>/`. Each file contained only an initialization message with no actual observations. The hypothesis was that `startSessionProcessor()` in startup-recovery created new observer sessions in a loop.
+
+**Current State:** The issue was **fixed in commit 9a7f662** with a deterministic `mem-${contentSessionId}` prefix approach, but this fix was **reverted in commit f9197b5** due to the SDK not accepting custom session IDs. The current code uses a NULL-based initialization pattern that can still create orphaned sessions under certain conditions.
+
+---
+
+## Evidence: Current File Analysis
+
+Filesystem analysis of `~/.claude/projects/-Users-alexnewman-Scripts-claude-mem/`:
+
+| Line Count | Number of Files |
+|------------|-----------------|
+| 0 lines (empty) | 407 |
+| 1 line | **12,562** |
+| 2 lines | 3,199 |
+| 3+ lines | 3,546 |
+| **Total** | **~19,714** |
+
+The 12,562 single-line files are consistent with the issue description - sessions that initialized but never received observations.
+
+Sample single-line file content:
+```json
+{"type":"queue-operation","operation":"dequeue","timestamp":"2025-12-28T20:41:25.484Z","sessionId":"00081a3b-9485-48a4-89f0-fd4dfccd3ac9"}
+```
+
+---
+
+## Root Cause Analysis
+
+### The Problem Chain
+
+1. **Worker startup calls `processPendingQueues()`** (line 281 in worker-service.ts)
+2. For each session with pending messages, it calls `initializeSession()` then `startSessionProcessor()`
+3. `startSessionProcessor()` invokes `sdkAgent.startSession()` which calls the Claude Agent SDK `query()` function
+4. **If `memorySessionId` is NULL**, no `resume` parameter is passed to `query()`
+5. **The SDK creates a NEW .jsonl file** for each query call without a resume parameter
+6. **If the query aborts before receiving a response** (timeout, crash, abort signal), the `memorySessionId` is never captured
+7. On next startup, the cycle repeats - creating yet another orphaned file
+
+### Why Sessions Abort Before Capturing memorySessionId
+
+Looking at `startSessionProcessor()` flow:
+
+```typescript
+// worker-service.ts lines 301-321
+private startSessionProcessor(session, source) {
+  session.generatorPromise = this.sdkAgent.startSession(session, this)
+    .catch(error => { /* error handling */ })
+    .finally(() => {
+      session.generatorPromise = null;
+      this.broadcastProcessingStatus();
+    });
+}
+```
+
+And `processPendingQueues()`:
+
+```typescript
+// worker-service.ts lines 347-371
+for (const sessionDbId of orphanedSessionIds) {
+  const session = this.sessionManager.initializeSession(sessionDbId);
+  this.startSessionProcessor(session, 'startup-recovery');
+  await new Promise(resolve => setTimeout(resolve, 100));  // 100ms delay between sessions
+}
+```
+
+The problem: Starting 50 sessions rapidly (100ms delay) with pending messages means:
+- All 50 SDK queries start nearly simultaneously
+- The SDK creates 50 new .jsonl files (since none have memorySessionId yet)
+- If any query fails/aborts before the first response, its memorySessionId is never captured
+- On next startup, those sessions get new files again
+
+---
+
+## Code Flow: Where .jsonl Files Are Created
+
+The .jsonl files are created by the **Claude Agent SDK** (`@anthropic-ai/claude-agent-sdk`), not by claude-mem directly.
+
+When `query()` is called in SDKAgent.ts:
+
+```typescript
+// SDKAgent.ts lines 89-99
+const queryResult = query({
+  prompt: messageGenerator,
+  options: {
+    model: modelId,
+    // Resume with captured memorySessionId (null on first prompt, real ID on subsequent)
+    ...(hasRealMemorySessionId && { resume: session.memorySessionId }),
+    disallowedTools,
+    abortController: session.abortController,
+    pathToClaudeCodeExecutable: claudePath
+  }
+});
+```
+
+**Key insight:** If `hasRealMemorySessionId` is false (memorySessionId is null), no `resume` parameter is passed. The SDK then generates a new UUID and creates a new file at:
+`~/.claude/projects/<dashed-cwd>/<new-uuid>.jsonl`
+
+---
+
+## Fix History
+
+### Commit 9a7f662: The Original Fix (Reverted)
+
+```
+fix(sdk): always pass deterministic session ID to prevent orphaned files
+
+Fixes #514 - Excessive observer sessions created during startup-recovery
+
+Root cause: When memorySessionId was null, no `resume` parameter was passed
+to the SDK's query(). This caused the SDK to create a NEW session file on
+every call. If queries aborted before capturing the SDK's session_id, the
+placeholder remained, leading to cascading creation of 13,000+ orphaned files.
+
+Fix:
+- Generate deterministic ID `mem-${contentSessionId}` upfront
+- Always pass it to `resume` parameter
+- Persist immediately to database before query starts
+- If SDK returns different ID, capture and use that going forward
+```
+
+**This fix was correct in approach** - always passing a resume parameter prevents new file creation.
+
+### Commit f9197b5: The Revert
+
+```
+fix(sdk): restore session continuity via robust capture-and-resume strategy
+
+Replaces the deterministic 'mem-' ID approach with a capture-based strategy:
+1. Passes 'resume' parameter ONLY when a verified memory session ID exists
+2. Captures SDK-generated session ID when it differs from current ID
+3. Ensures subsequent prompts resume the correctly captured session ID
+
+This resolves the issue where new sessions were created for every message
+due to failure to capture/resume the initial session ID, without introducing
+potentially invalid deterministic IDs.
+```
+
+**The revert explanation suggests the SDK rejected the `mem-` prefix IDs.**
+
+### Commit 005b0f8: Current NULL-based Pattern
+
+Changed `memory_session_id` initialization from `contentSessionId` (placeholder) to `NULL`:
+- Simpler logic: `!!session.memorySessionId` instead of `memorySessionId !== contentSessionId`
+- But still creates new files on first prompt of each session
+
+---
+
+## Relationship with Issue #520 (Stuck Messages)
+
+**Issue #520 is related but distinct:**
+
+| Aspect | Issue #514 (Orphaned Files) | Issue #520 (Stuck Messages) |
+|--------|-----------------------------|-----------------------------|
+| Problem | Too many .jsonl files | Messages never processed |
+| Root Cause | SDK creates new file per query without resume | Old claim-process-mark pattern left messages in 'processing' state |
+| Status | Partially resolved | **Fully resolved** |
+| Fix | Need deterministic resume IDs | Changed to claim-and-delete pattern |
+
+**Connection:** Both issues relate to startup-recovery. Issue #520's fix (claim-and-delete pattern) doesn't create the loop that #514 describes, but #514 can still occur when:
+1. Sessions have pending messages
+2. Recovery starts the generator
+3. Generator aborts before capturing memorySessionId
+4. Next startup repeats the cycle
+
+---
+
+## v8.5.7 Status
+
+**v8.5.7 did NOT fully address Issue #514.** The major changes were:
+- Modular architecture refactor
+- NULL-based initialization pattern
+- Comprehensive test coverage
+
+The deterministic `mem-` prefix fix (9a7f662) was reverted before v8.5.7.
+
+---
+
+## Recommended Fix
+
+### Option 1: Reintroduce Deterministic IDs with SDK Validation
+
+```typescript
+// SDKAgent.ts - In startSession()
+async startSession(session: ActiveSession, worker?: WorkerRef): Promise<void> {
+  // Generate deterministic ID based on database session ID (not UUID-based contentSessionId)
+  // Format: "mem-<sessionDbId>" is short and unlikely to conflict
+  const deterministicMemoryId = session.memorySessionId || `mem-${session.sessionDbId}`;
+
+  // Always pass resume to prevent orphaned sessions
+  const queryResult = query({
+    prompt: messageGenerator,
+    options: {
+      model: modelId,
+      resume: deterministicMemoryId,  // ALWAYS pass, even if SDK might reject
+      disallowedTools,
+      abortController: session.abortController,
+      pathToClaudeCodeExecutable: claudePath
+    }
+  });
+
+  // Capture whatever ID the SDK actually uses
+  for await (const message of queryResult) {
+    if (message.session_id && message.session_id !== session.memorySessionId) {
+      session.memorySessionId = message.session_id;
+      this.dbManager.getSessionStore().updateMemorySessionId(
+        session.sessionDbId,
+        message.session_id
+      );
+    }
+    // ... rest of processing
+  }
+}
+```
+
+### Option 2: Limit Recovery Scope
+
+Prevent the recovery loop by limiting how many times a session can be recovered:
+
+```typescript
+// In processPendingQueues()
+for (const sessionDbId of orphanedSessionIds) {
+  // Check if this session was already recovered recently
+  const dbSession = this.dbManager.getSessionById(sessionDbId);
+  const recoveryAttempts = dbSession.recovery_attempts || 0;
+
+  if (recoveryAttempts >= 3) {
+    logger.warn('SYSTEM', 'Session exceeded max recovery attempts, skipping', {
+      sessionDbId,
+      recoveryAttempts
+    });
+    continue;
+  }
+
+  // Increment recovery counter
+  this.dbManager.getSessionStore().incrementRecoveryAttempts(sessionDbId);
+
+  // ... rest of recovery
+}
+```
+
+### Option 3: Cleanup Old Files (Mitigation, Not Fix)
+
+Add a cleanup script that removes orphaned .jsonl files:
+
+```bash
+# Find files with only 1 line older than 7 days
+find ~/.claude/projects/ -name "*.jsonl" -mtime +7 \
+  -exec sh -c '[ $(wc -l < "$1") -le 1 ] && rm "$1"' _ {} \;
+```
+
+---
+
+## Files Involved
+
+| File | Role |
+|------|------|
+| `src/services/worker-service.ts` | `startSessionProcessor()`, `processPendingQueues()` |
+| `src/services/worker/SDKAgent.ts` | `startSession()`, `query()` call with `resume` parameter |
+| `src/services/worker/SessionManager.ts` | `initializeSession()`, session lifecycle |
+| `src/services/sqlite/sessions/create.ts` | `createSDKSession()`, NULL-based initialization |
+| `src/services/sqlite/PendingMessageStore.ts` | `getSessionsWithPendingMessages()` |
+
+---
+
+## Conclusion
+
+Issue #514 was correctly diagnosed. The fix in commit 9a7f662 was the right approach but was reverted because the SDK may not accept arbitrary custom IDs. The current NULL-based pattern (005b0f8) is cleaner but doesn't prevent orphaned files when queries abort before capturing the SDK's session ID.
+
+**Recommendation:** Reintroduce the deterministic ID approach with proper handling of SDK rejections (Option 1). If the SDK rejects the ID and returns a different one, capture and persist that ID immediately. This ensures at most one .jsonl file per database session, even across crashes and restarts.
+
+---
+
+## Appendix: Git Commit References
+
+| Commit | Description |
+|--------|-------------|
+| 9a7f662 | Original fix: deterministic `mem-` prefix IDs (REVERTED) |
+| f9197b5 | Revert: capture-based strategy without deterministic IDs |
+| 005b0f8 | NULL-based initialization pattern (current) |
+| d72a81e | Queue refactoring (related to #520) |
+| eb1a78b | Claim-and-delete pattern (fixes #520) |
@@ -0,0 +1,87 @@
+# Issue #517 Analysis: Windows PowerShell Escaping in cleanupOrphanedProcesses()
+
+**Date:** 2026-01-04
+**Version Analyzed:** 8.5.7
+**Status:** NOT FIXED - Issue still present
+
+## Summary
+
+The reported issue involves PowerShell's `$_` variable being interpreted by Bash before PowerShell receives it when running in Git Bash or WSL environments on Windows. This causes `cleanupOrphanedProcesses()` to fail during worker initialization.
+
+## Current State
+
+The `cleanupOrphanedProcesses()` function is located in:
+- **File:** `/Users/alexnewman/Scripts/claude-mem/src/services/infrastructure/ProcessManager.ts`
+- **Lines:** 164-251
+
+### Problematic Code (Lines 170-172)
+
+```typescript
+if (isWindows) {
+  // Windows: Use PowerShell Get-CimInstance to find chroma-mcp processes
+  const cmd = `powershell -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -like '*python*' -and $_.CommandLine -like '*chroma-mcp*' } | Select-Object -ExpandProperty ProcessId"`;
+  const { stdout } = await execAsync(cmd, { timeout: 60000 });
+```
+
+The `$_.Name` and `$_.CommandLine` contain `$_` which is a special variable in both PowerShell and Bash. When this command string is executed via Node.js `child_process.exec()` in a Git Bash or WSL environment, Bash may interpret `$_` as its own special variable (the last argument of the previous command) before passing it to PowerShell.
+
+### Additional Occurrence (Lines 91-92)
+
+A similar issue exists in `getChildProcesses()`:
+
+```typescript
+const cmd = `powershell -Command "Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -eq ${parentPid} } | Select-Object -ExpandProperty ProcessId"`;
+```
+
+## Error Handling Analysis
+
+Both functions have try-catch blocks with non-blocking error handling:
+- Line 208-212: `cleanupOrphanedProcesses()` catches errors and logs a warning, then returns
+- Line 98-102: `getChildProcesses()` catches errors and logs a warning, returning empty array
+
+While this prevents worker initialization from crashing, it means orphaned process cleanup silently fails on affected Windows environments.
+
+## Recommended Fix
+
+Replace PowerShell commands with WMIC (Windows Management Instrumentation Command-line), which does not use `$_` syntax:
+
+### For cleanupOrphanedProcesses() (Line 171):
+
+**Current:**
+```typescript
+const cmd = `powershell -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -like '*python*' -and $_.CommandLine -like '*chroma-mcp*' } | Select-Object -ExpandProperty ProcessId"`;
+```
+
+**Recommended:**
+```typescript
+const cmd = `wmic process where "name like '%python%' and commandline like '%chroma-mcp%'" get processid /format:list`;
+```
+
+### For getChildProcesses() (Line 91):
+
+**Current:**
+```typescript
+const cmd = `powershell -Command "Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -eq ${parentPid} } | Select-Object -ExpandProperty ProcessId"`;
+```
+
+**Recommended:**
+```typescript
+const cmd = `wmic process where "parentprocessid=${parentPid}" get processid /format:list`;
+```
+
+### Implementation Notes
+
+1. WMIC output format differs from PowerShell - parse `ProcessId=12345` format
+2. WMIC is deprecated in newer Windows versions but still widely available
+3. Alternative: Use PowerShell with proper escaping (`$$_` or `\$_` depending on context)
+4. Consider using `powershell -NoProfile -NonInteractive` flags for faster execution
+
+## Impact Assessment
+
+- **Severity:** Medium - orphaned process cleanup fails silently
+- **Scope:** Windows users running in Git Bash, WSL, or mixed shell environments
+- **Workaround:** None currently - users must manually kill orphaned chroma-mcp processes
+
+## Files to Modify
+
+1. `/src/services/infrastructure/ProcessManager.ts` (lines 91-92, 171-172)
@@ -0,0 +1,210 @@
+# Issue #520: Stuck Messages Analysis
+
+**Date:** January 4, 2026
+**Status:** RESOLVED - Issue no longer exists in current codebase
+**Original Issue:** Messages in 'processing' status never recovered after worker crash
+
+---
+
+## Executive Summary
+
+The issue described in GitHub #520 has been **fully resolved** in the current codebase through a fundamental architectural change. The system now uses a **claim-and-delete** pattern instead of the old **claim-process-mark** pattern, which eliminates the stuck 'processing' state problem entirely.
+
+---
+
+## Original Issue Description
+
+The issue claimed that after a worker crash:
+
+1. `getSessionsWithPendingMessages()` returns sessions with `status IN ('pending', 'processing')`
+2. But `claimNextMessage()` only looks for `status = 'pending'`
+3. So 'processing' messages are orphaned
+
+**Proposed Fix:** Add `resetStuckMessages(0)` at start of `processPendingQueues()`
+
+---
+
+## Current Code Analysis
+
+### 1. Queue Processing Pattern: Claim-and-Delete
+
+The current architecture uses `claimAndDelete()` instead of `claimNextMessage()`:
+
+**File:** `/Users/alexnewman/Scripts/claude-mem/src/services/sqlite/PendingMessageStore.ts`
+
+```typescript
+// Lines 85-104
+claimAndDelete(sessionDbId: number): PersistentPendingMessage | null {
+  const claimTx = this.db.transaction((sessionId: number) => {
+    const peekStmt = this.db.prepare(`
+      SELECT * FROM pending_messages
+      WHERE session_db_id = ? AND status = 'pending'
+      ORDER BY id ASC
+      LIMIT 1
+    `);
+    const msg = peekStmt.get(sessionId) as PersistentPendingMessage | null;
+
+    if (msg) {
+      // Delete immediately - no "processing" state needed
+      const deleteStmt = this.db.prepare('DELETE FROM pending_messages WHERE id = ?');
+      deleteStmt.run(msg.id);
+    }
+    return msg;
+  });
+
+  return claimTx(sessionDbId) as PersistentPendingMessage | null;
+}
+```
+
+**Key insight:** Messages are atomically selected and deleted in a single transaction. There is no 'processing' state for messages being actively worked on - they simply don't exist in the database anymore.
+
+### 2. Iterator Uses claimAndDelete
+
+**File:** `/Users/alexnewman/Scripts/claude-mem/src/services/queue/SessionQueueProcessor.ts`
+
+```typescript
+// Lines 18-38
+async *createIterator(sessionDbId: number, signal: AbortSignal): AsyncIterableIterator<PendingMessageWithId> {
+  while (!signal.aborted) {
+    try {
+      // Atomically claim AND DELETE next message from DB
+      // Message is now in memory only - no "processing" state tracking needed
+      const persistentMessage = this.store.claimAndDelete(sessionDbId);
+
+      if (persistentMessage) {
+        // Yield the message for processing (it's already deleted from queue)
+        yield this.toPendingMessageWithId(persistentMessage);
+      } else {
+        // Queue empty - wait for wake-up event
+        await this.waitForMessage(signal);
+      }
+    } catch (error) {
+      // ... error handling
+    }
+  }
+}
+```
+
+### 3. getSessionsWithPendingMessages Still Checks Both States
+
+**File:** `/Users/alexnewman/Scripts/claude-mem/src/services/sqlite/PendingMessageStore.ts`
+
+```typescript
+// Lines 319-326
+getSessionsWithPendingMessages(): number[] {
+  const stmt = this.db.prepare(`
+    SELECT DISTINCT session_db_id FROM pending_messages
+    WHERE status IN ('pending', 'processing')
+  `);
+  const results = stmt.all() as { session_db_id: number }[];
+  return results.map(r => r.session_db_id);
+}
+```
+
+**This is technically vestigial code** - with the claim-and-delete pattern, messages should never be in 'processing' state. However, it provides backward compatibility and defense-in-depth.
+
+### 4. Startup Recovery Still Exists
+
+**File:** `/Users/alexnewman/Scripts/claude-mem/src/services/worker-service.ts`
+
+```typescript
+// Lines 236-242
+// Recover stuck messages from previous crashes
+const { PendingMessageStore } = await import('./sqlite/PendingMessageStore.js');
+const pendingStore = new PendingMessageStore(this.dbManager.getSessionStore().db, 3);
+const STUCK_THRESHOLD_MS = 5 * 60 * 1000;
+const resetCount = pendingStore.resetStuckMessages(STUCK_THRESHOLD_MS);
+if (resetCount > 0) {
+  logger.info('SYSTEM', `Recovered ${resetCount} stuck messages from previous session`, { thresholdMinutes: 5 });
+}
+```
+
+This runs BEFORE `processPendingQueues()` is called (line 281), which addresses the original fix request.
+
+---
+
+## Verification of Issue Status
+
+### Does the Issue Exist?
+
+**NO** - The issue as described no longer exists because:
+
+1. **No 'processing' state during normal operation**: With claim-and-delete, messages go directly from 'pending' to 'deleted'. They never enter a 'processing' state.
+
+2. **Startup recovery handles legacy stuck messages**: Even if 'processing' messages exist (from old code or edge cases), `resetStuckMessages()` is called BEFORE `processPendingQueues()` in `initializeBackground()` (lines 236-241 run before line 281).
+
+3. **Architecture fundamentally changed**: The old `claimNextMessage()` function that only looked for `status = 'pending'` no longer exists. It was replaced with `claimAndDelete()`.
+
+### GeminiAgent and OpenRouterAgent Behavior
+
+Both agents use the same `SessionManager.getMessageIterator()` which calls `SessionQueueProcessor.createIterator()` which uses `claimAndDelete()`. All three agents (SDKAgent, GeminiAgent, OpenRouterAgent) use identical queue processing:
+
+```typescript
+// GeminiAgent.ts:174, OpenRouterAgent.ts:134
+for await (const message of this.sessionManager.getMessageIterator(session.sessionDbId)) {
+  // ...
+}
+```
+
+They do NOT handle recovery differently - they all rely on the shared infrastructure.
+
+### What v8.5.7 Changed
+
+Looking at the git history:
+
+```
+v8.5.7 (ac03901):
+- Minor ESM/CommonJS compatibility fix for isMainModule detection
+- No queue-related changes
+
+v8.5.6 -> v8.5.7:
+- f21ea97 refactor: decompose monolith into modular architecture with comprehensive test suite (#538)
+```
+
+The major refactor happened before v8.5.7. The claim-and-delete pattern was already in place.
+
+---
+
+## Timeline of Resolution
+
+Based on git history, the issue was likely resolved through these commits:
+
+1. **b8ce27b** - `feat(queue): Simplify queue processing and enhance reliability`
+2. **eb1a78b** - `fix: eliminate duplicate observations by simplifying message queue`
+3. **d72a81e** - `Refactor session queue processing and database interactions`
+
+These commits appear to have introduced the claim-and-delete pattern that eliminates the original bug.
+
+---
+
+## Conclusion
+
+**Issue #520 should be closed as resolved.**
+
+The described bug (`claimNextMessage()` only checking `status = 'pending'`) no longer exists because:
+
+1. `claimNextMessage()` was replaced with `claimAndDelete()` which atomically removes messages
+2. `resetStuckMessages()` is already called at startup BEFORE `processPendingQueues()`
+3. The 'processing' status is now only used for legacy compatibility and edge cases
+
+### No Fix Needed
+
+The proposed fix ("Add `resetStuckMessages(0)` at start of `processPendingQueues()`") is:
+
+1. **Unnecessary** - The recovery happens in `initializeBackground()` before `processPendingQueues()` is called
+2. **Using wrong threshold** - `resetStuckMessages(0)` would reset ALL processing messages immediately, which could cause issues if called during normal operation (not just startup)
+
+The current implementation with a 5-minute threshold is more robust - it only recovers truly stuck messages, not messages that are actively being processed.
+
+---
+
+## Appendix: File References
+
+| Component | File | Key Lines |
+|-----------|------|-----------|
+| claimAndDelete | `src/services/sqlite/PendingMessageStore.ts` | 85-104 |
+| Queue Iterator | `src/services/queue/SessionQueueProcessor.ts` | 18-38 |
+| Startup Recovery | `src/services/worker-service.ts` | 236-242 |
+| processPendingQueues | `src/services/worker-service.ts` | 326-375 |
+| getSessionsWithPendingMessages | `src/services/sqlite/PendingMessageStore.ts` | 319-326 |
+| resetStuckMessages | `src/services/sqlite/PendingMessageStore.ts` | 279-290 |
--- a/Show More
+++ b/Show More