kyp-mem 0.4.2 → 0.4.4

package/bin/cli.mjs

@@ -60,6 +60,23 @@ if (args[0] === "hook") {
   await new Promise((r) => process.stdin.on("end", r));
   const raw = Buffer.concat(chunks).toString();
 
+  if (hookType === "user-prompt") {
+    try {
+      const data = JSON.parse(raw);
+      const prompt = (data.prompt || "").trim();
+      if (!prompt) process.exit(0);
+      const entry = {
+        ts: new Date().toISOString(),
+        cwd: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+        action: "prompt",
+        prompt,
+      };
+      mkdirSync(sessionDir, { recursive: true });
+      appendFileSync(sessionFile, JSON.stringify(entry) + "\n");
+    } catch (_) {}
+    process.exit(0);
+  }
+
   if (hookType === "post-tool-use") {
     try {
       const data = JSON.parse(raw);
@@ -72,6 +89,9 @@ if (args[0] === "hook") {
       if (tool === "Edit" || tool === "Write") {
         entry.file = input.file_path || "";
         entry.action = tool === "Edit" ? "edit" : "create";
+      } else if (tool === "Read") {
+        entry.file = input.file_path || "";
+        entry.action = "read";
       } else if (tool === "Bash") {
         entry.command = (input.command || "").slice(0, 300);
         entry.action = "command";

package/kyp_mem/cli.py

@@ -45,6 +45,7 @@ def main():
 
     hook_parser = subparsers.add_parser("hook", help="Handle Claude Code hook events (internal)")
     hook_sub = hook_parser.add_subparsers(dest="hook_command")
+    hook_sub.add_parser("session-start", help="Inject project context at session start")
     hook_sub.add_parser("post-tool-use", help="Capture tool activity to session log")
     hook_sub.add_parser("user-prompt", help="Capture user prompt to session log")
     hook_sub.add_parser("stop", help="Compile session into vault note")
@@ -73,8 +74,10 @@ def main():
     elif args.command == "doctor":
         _run_doctor()
     elif args.command == "hook":
-        from .hooks import handle_post_tool_use, handle_user_prompt, handle_stop
-        if args.hook_command == "post-tool-use":
+        from .hooks import handle_session_start, handle_post_tool_use, handle_user_prompt, handle_stop
+        if args.hook_command == "session-start":
+            handle_session_start()
+        elif args.hook_command == "post-tool-use":
             handle_post_tool_use()
         elif args.hook_command == "user-prompt":
             handle_user_prompt()
@@ -286,7 +289,7 @@ def _run_install_hooks(global_config: bool = False, remove: bool = False):
 
     if remove:
         changed = False
-        for event in ("PostToolUse", "UserPromptSubmit", "Stop"):
+        for event in ("SessionStart", "PostToolUse", "UserPromptSubmit", "Stop"):
             if event in hooks:
                 hooks[event] = [h for h in hooks[event] if not _has_kyp_hook(h)]
                 if not hooks[event]:
@@ -301,16 +304,21 @@ def _run_install_hooks(global_config: bool = False, remove: bool = False):
         print()
         return
 
+    session_start_hooks = hooks.setdefault("SessionStart", [])
     post_tool_hooks = hooks.setdefault("PostToolUse", [])
     prompt_hooks = hooks.setdefault("UserPromptSubmit", [])
     stop_hooks = hooks.setdefault("Stop", [])
 
+    session_start_hooks = [h for h in session_start_hooks if not _has_kyp_hook(h)]
     post_tool_hooks = [h for h in post_tool_hooks if not _has_kyp_hook(h)]
     prompt_hooks = [h for h in prompt_hooks if not _has_kyp_hook(h)]
     stop_hooks = [h for h in stop_hooks if not _has_kyp_hook(h)]
 
+    session_start_hooks.append({
+        "hooks": [{"type": "command", "command": f"{mcp_command} hook session-start"}],
+    })
     post_tool_hooks.append({
-        "matcher": "Edit|Write|Bash",
+        "matcher": "Edit|Write|Read|Bash",
         "hooks": [{"type": "command", "command": f"{mcp_command} hook post-tool-use"}],
     })
     prompt_hooks.append({
@@ -320,6 +328,7 @@ def _run_install_hooks(global_config: bool = False, remove: bool = False):
         "hooks": [{"type": "command", "command": f"{mcp_command} hook stop"}],
     })
 
+    hooks["SessionStart"] = session_start_hooks
     hooks["PostToolUse"] = post_tool_hooks
     hooks["UserPromptSubmit"] = prompt_hooks
     hooks["Stop"] = stop_hooks

package/kyp_mem/hooks.py

@@ -12,6 +12,81 @@ CURRENT_SESSION = SESSION_DIR / "current.jsonl"
 MIN_ACTIONS = 3
 
 
+def handle_session_start():
+    """Inject project context into the conversation at session start."""
+    sys.stdin.read()
+
+    cwd = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+    project_name = Path(cwd).name
+
+    try:
+        from .config import get_vault_path
+        from .vault import Vault
+
+        vault = Vault(get_vault_path())
+
+        project_notes = [p for p in vault.index.notes if p.startswith(f"{project_name}/")]
+        if not project_notes:
+            return
+
+        parts = [f"# [kyp-mem] {project_name} — Project Context"]
+        parts.append(f"Vault: {get_vault_path()}")
+        parts.append("")
+
+        knowledge_path = f"{project_name}/Knowledge.md"
+        knowledge = vault.read(knowledge_path)
+        if knowledge:
+            parts.append("## Knowledge")
+            content = knowledge.content
+            timeline_idx = content.find("## Timeline")
+            if timeline_idx > 0:
+                content = content[:timeline_idx].strip()
+            if len(content) > 2000:
+                parts.append(content[:2000] + "\n...")
+            else:
+                parts.append(content)
+            parts.append("")
+
+        other_notes = sorted(
+            p for p in project_notes
+            if "/Sessions/" not in p and p != knowledge_path
+        )
+        if other_notes:
+            parts.append("## Project Notes")
+            for p in other_notes:
+                note = vault.index.notes.get(p)
+                title = note.title if note else p
+                tags = f" [{', '.join(note.tags)}]" if note and note.tags else ""
+                parts.append(f"- {title} ({p}){tags}")
+            parts.append("")
+
+        sessions = sorted(
+            (p for p in project_notes if "/Sessions/" in p),
+            reverse=True,
+        )[:3]
+        if sessions:
+            parts.append(f"## Recent Sessions (last {len(sessions)})")
+            for sp in sessions:
+                note = vault.read(sp)
+                if not note:
+                    continue
+                parts.append(f"### {note.title}")
+                content = note.content
+                timeline_idx = content.find("## Timeline")
+                if timeline_idx > 0:
+                    content = content[:timeline_idx].strip()
+                if len(content) > 300:
+                    content = content[:300] + "..."
+                parts.append(content)
+                parts.append("")
+
+        parts.append("Use `kyp_project_context` for full details. Use `kyp_session_search` to search past sessions.")
+
+        print("\n".join(parts))
+    except Exception:
+        pass
+
+
 def handle_user_prompt():
     raw = sys.stdin.read().strip()
     if not raw:
@@ -60,6 +135,9 @@ def handle_post_tool_use():
     elif tool_name == "Write":
         entry["action"] = "create"
         entry["file"] = tool_input.get("file_path", "")
+    elif tool_name == "Read":
+        entry["action"] = "read"
+        entry["file"] = tool_input.get("file_path", "")
     elif tool_name == "Bash":
         entry["action"] = "command"
         entry["command"] = tool_input.get("command", "")
@@ -71,6 +149,197 @@ def handle_post_tool_use():
         f.write(json.dumps(entry) + "\n")
 
 
+def _relative_path(filepath, project_dir):
+    try:
+        return str(Path(filepath).relative_to(project_dir))
+    except (ValueError, TypeError):
+        return Path(filepath).name if filepath else ""
+
+
+def _group_files_by_dir(filepaths, project_dir):
+    groups = {}
+    for fp in sorted(filepaths):
+        rel = _relative_path(fp, project_dir)
+        parent = str(Path(rel).parent)
+        if parent == ".":
+            parent = "(root)"
+        groups.setdefault(parent, []).append(Path(rel).name)
+    return groups
+
+
+def _classify_command(cmd):
+    if not cmd.strip():
+        return "other", ""
+    first = cmd.strip().split()[0]
+    search_cmds = {'grep', 'rg', 'ag', 'ack'}
+    explore_cmds = {'find', 'fd', 'ls', 'tree', 'du'}
+    read_cmds = {'cat', 'head', 'tail', 'less', 'more', 'wc', 'file'}
+    diff_cmds = {'diff', 'git diff', 'git log', 'git status', 'git show'}
+    test_cmds = {'pytest', 'python -m pytest', 'npm test', 'jest', 'mocha', 'cargo test', 'go test'}
+    build_cmds = {'npm run', 'npm install', 'pip install', 'make', 'cargo build', 'go build'}
+    server_cmds = {'python3 -m', 'uvicorn', 'node', 'npm start', 'flask run'}
+    git_cmds = {'git commit', 'git push', 'git add', 'git checkout', 'git branch', 'git merge', 'git stash'}
+
+    if first in search_cmds or cmd.strip().startswith('git grep'):
+        return "search", cmd
+    if first in explore_cmds:
+        return "explore", cmd
+    if first in read_cmds:
+        return "read_cmd", cmd
+    for prefix in diff_cmds:
+        if cmd.strip().startswith(prefix):
+            return "git_inspect", cmd
+    for prefix in test_cmds:
+        if cmd.strip().startswith(prefix):
+            return "test", cmd
+    for prefix in build_cmds:
+        if cmd.strip().startswith(prefix):
+            return "build", cmd
+    for prefix in git_cmds:
+        if cmd.strip().startswith(prefix):
+            return "git_write", cmd
+    for prefix in server_cmds:
+        if cmd.strip().startswith(prefix):
+            return "run", cmd
+    if first == 'curl':
+        return "api_test", cmd
+    return "other", cmd
+
+
+def _build_investigated(files_read, commands_classified, project_dir):
+    items = []
+    seen_files = set()
+
+    search_cmds = [cmd for cls, cmd in commands_classified if cls == "search"]
+    for cmd in search_cmds[:8]:
+        parts = cmd.strip().split()
+        if len(parts) >= 2:
+            pattern = None
+            for i, p in enumerate(parts):
+                if not p.startswith('-') and i > 0:
+                    pattern = p.strip("'\"")
+                    break
+            if pattern:
+                items.append(f"- Searched for `{pattern[:60]}`")
+            else:
+                items.append(f"- `{cmd[:100]}`")
+
+    read_groups = _group_files_by_dir(files_read, project_dir)
+    for dir_name, filenames in read_groups.items():
+        unique = [f for f in filenames if f not in seen_files]
+        seen_files.update(unique)
+        if not unique:
+            continue
+        if len(unique) <= 3:
+            items.append(f"- Read {', '.join(f'`{f}`' for f in unique)}")
+        else:
+            items.append(f"- Read {len(unique)} files in `{dir_name}/`")
+
+    explore_cmds = [cmd for cls, cmd in commands_classified if cls == "explore"]
+    if explore_cmds:
+        items.append(f"- Explored project structure ({len(explore_cmds)} commands)")
+
+    git_cmds = [cmd for cls, cmd in commands_classified if cls == "git_inspect"]
+    if git_cmds:
+        items.append(f"- Inspected git history/diff ({len(git_cmds)} commands)")
+
+    api_cmds = [cmd for cls, cmd in commands_classified if cls == "api_test"]
+    if api_cmds:
+        items.append(f"- Tested API endpoints ({len(api_cmds)} requests)")
+
+    return items
+
+
+def _build_learned(files_read, files_edited, files_created, commands_classified, project_dir):
+    items = []
+    read_set = {Path(f).name for f in files_read}
+    edit_set = {Path(f).name for f in files_edited}
+    create_set = {Path(f).name for f in files_created}
+
+    investigated_then_modified = read_set & edit_set
+    if investigated_then_modified:
+        names = sorted(investigated_then_modified)[:5]
+        items.append(f"- Investigated and modified: {', '.join(f'`{n}`' for n in names)}")
+
+    config_files = {f for f in (files_edited | files_created)
+                    if any(f.endswith(ext) for ext in
+                           ('.json', '.toml', '.yaml', '.yml', '.ini', '.cfg', '.env', '.conf'))}
+    if config_files:
+        items.append(f"- Configuration changes: {', '.join(f'`{Path(f).name}`' for f in sorted(config_files)[:4])}")
+
+    test_cmds = [cmd for cls, cmd in commands_classified if cls == "test"]
+    if test_cmds:
+        items.append(f"- Ran tests ({len(test_cmds)} run{'s' if len(test_cmds) != 1 else ''})")
+
+    new_only = create_set - read_set
+    if new_only:
+        items.append(f"- Created new files: {', '.join(f'`{n}`' for n in sorted(new_only)[:5])}")
+
+    return items
+
+
+def _build_completed(files_edited, files_created, commands_classified, project_dir):
+    items = []
+
+    edit_groups = _group_files_by_dir(files_edited, project_dir)
+    for dir_name, filenames in edit_groups.items():
+        if len(filenames) == 1:
+            items.append(f"- Modified `{filenames[0]}`")
+        else:
+            items.append(f"- Modified {len(filenames)} files in `{dir_name}/`: {', '.join(f'`{f}`' for f in filenames[:5])}")
+
+    create_groups = _group_files_by_dir(files_created, project_dir)
+    for dir_name, filenames in create_groups.items():
+        if len(filenames) == 1:
+            items.append(f"- Created `{filenames[0]}`")
+        else:
+            items.append(f"- Created {len(filenames)} files in `{dir_name}/`")
+
+    test_cmds = [cmd for cls, cmd in commands_classified if cls == "test"]
+    if test_cmds:
+        items.append(f"- Ran test suite")
+
+    git_writes = [cmd for cls, cmd in commands_classified if cls == "git_write"]
+    for cmd in git_writes:
+        if 'commit' in cmd:
+            items.append("- Committed changes to git")
+            break
+    for cmd in git_writes:
+        if 'push' in cmd:
+            items.append("- Pushed to remote")
+            break
+
+    build_cmds = [cmd for cls, cmd in commands_classified if cls == "build"]
+    if build_cmds:
+        items.append("- Ran build/install")
+
+    run_cmds = [cmd for cls, cmd in commands_classified if cls == "run"]
+    if run_cmds:
+        items.append("- Started/tested server")
+
+    return items
+
+
+def _build_next_steps(files_edited, files_created, commands_classified):
+    items = []
+
+    git_writes = {cmd for cls, cmd in commands_classified if cls == "git_write"}
+    has_commit = any('commit' in cmd for cmd in git_writes)
+    has_push = any('push' in cmd for cmd in git_writes)
+
+    all_changed = files_edited | files_created
+    if all_changed and not has_commit:
+        items.append("- Commit pending changes")
+    if has_commit and not has_push:
+        items.append("- Push committed changes to remote")
+
+    test_cmds = [cmd for cls, cmd in commands_classified if cls == "test"]
+    if not test_cmds and all_changed:
+        items.append("- Run tests to verify changes")
+
+    return items
+
+
 def handle_stop():
     if not CURRENT_SESSION.exists():
         return
@@ -100,6 +369,7 @@ def handle_stop():
     project_name = Path(project_dir).name
     session_id = datetime.now().strftime("%Y-%m-%d_%H%M%S")
 
+    files_read = set()
     files_edited = set()
     files_created = set()
     commands = []
@@ -114,6 +384,10 @@ def handle_stop():
         if action == "prompt":
             prompts.append({"ts": ts, "text": e.get("prompt", "")})
             timeline.append(f"  {ts} — Prompt: {e.get('prompt', '')[:60]}...")
+        elif action == "read":
+            fp = e.get("file", "")
+            files_read.add(fp)
+            timeline.append(f"  {ts} — Read `{Path(fp).name}`")
         elif action == "edit":
             fp = e.get("file", "")
             files_edited.add(fp)
@@ -128,6 +402,8 @@ def handle_stop():
             short = cmd[:80] + "..." if len(cmd) > 80 else cmd
             timeline.append(f"  {ts} — `{short}`")
 
+    commands_classified = [_classify_command(cmd) for cmd in commands]
+
     summary_items = []
     if files_edited:
         summary_items.append(f"Modified {len(files_edited)} file{'s' if len(files_edited) != 1 else ''}")
@@ -136,12 +412,10 @@ def handle_stop():
     if commands:
         summary_items.append(f"Ran {len(commands)} command{'s' if len(commands) != 1 else ''}")
 
-    investigate_keywords = {'grep', 'find', 'cat', 'head', 'tail', 'less', 'ls', 'tree', 'rg', 'ag', 'fd', 'wc', 'diff'}
-    investigated_cmds = []
-    for cmd in commands:
-        first_word = cmd.strip().split()[0] if cmd.strip() else ''
-        if first_word in investigate_keywords:
-            investigated_cmds.append(cmd)
+    investigated = _build_investigated(files_read, commands_classified, project_dir)
+    learned = _build_learned(files_read, files_edited, files_created, commands_classified, project_dir)
+    completed = _build_completed(files_edited, files_created, commands_classified, project_dir)
+    next_steps = _build_next_steps(files_edited, files_created, commands_classified)
 
     parts = [f"# Session {session_id}", ""]
     parts.append(f"**Project:** `{project_dir}`")
@@ -161,27 +435,23 @@ def handle_stop():
     parts.append("")
 
     parts.append("## INVESTIGATED")
-    if investigated_cmds:
-        for cmd in investigated_cmds[:15]:
-            short = cmd[:120] + "..." if len(cmd) > 120 else cmd
-            parts.append(f"- `{short}`")
+    if investigated:
+        parts.extend(investigated)
     parts.append("")
 
     parts.append("## LEARNED")
-    parts.append("")
+    if learned:
+        parts.extend(learned)
     parts.append("")
 
     parts.append("## COMPLETED")
-    if files_edited:
-        for f in sorted(files_edited):
-            parts.append(f"- Modified `{Path(f).name}`")
-    if files_created:
-        for f in sorted(files_created):
-            parts.append(f"- Created `{Path(f).name}`")
+    if completed:
+        parts.extend(completed)
     parts.append("")
 
     parts.append("## NEXT STEPS")
-    parts.append("")
+    if next_steps:
+        parts.extend(next_steps)
     parts.append("")
 
     if timeline:

package/kyp_mem/server.py

@@ -324,11 +324,20 @@ def kyp_project_context(project: str) -> str:
     """CALL THIS AT SESSION START. Returns the project's full context: Knowledge.md (ground truth), project notes, and recent session summaries. Use this to understand architecture, known bugs, past decisions, and what was done recently. This prevents hallucination and avoids repeating past work."""
     parts = []
 
+    MAX_KNOWLEDGE_CHARS = 3000
+    MAX_NOTE_PREVIEW_LINES = 6
+    MAX_SESSION_CHARS = 400
+
     knowledge_path = f"{project}/Knowledge.md"
     knowledge = vault.read(knowledge_path)
     if knowledge:
         parts.append("=== PROJECT KNOWLEDGE ===")
-        parts.append(knowledge.content)
+        content = knowledge.content
+        if len(content) > MAX_KNOWLEDGE_CHARS:
+            parts.append(content[:MAX_KNOWLEDGE_CHARS])
+            parts.append(f"\n... (truncated — use kyp_read(\"{knowledge_path}\", full=True) for complete content)")
+        else:
+            parts.append(content)
         parts.append("")
 
     project_notes = []
@@ -341,9 +350,9 @@ def kyp_project_context(project: str) -> str:
         for path, note in sorted(project_notes):
             parts.append(f"\n--- {note.title} ({path}) ---")
             preview = note.content.strip().split("\n")
-            parts.append("\n".join(preview[:10]))
-            if len(preview) > 10:
-                parts.append("...")
+            parts.append("\n".join(preview[:MAX_NOTE_PREVIEW_LINES]))
+            if len(preview) > MAX_NOTE_PREVIEW_LINES:
+                parts.append(f"... (use kyp_read(\"{path}\", full=True) for complete content)")
         parts.append("")
 
     sessions = []
@@ -360,9 +369,11 @@ def kyp_project_context(project: str) -> str:
             content = note.content
             timeline_idx = content.find("## Timeline")
             if timeline_idx > 0:
-                parts.append(content[:timeline_idx].strip())
+                content = content[:timeline_idx].strip()
+            if len(content) > MAX_SESSION_CHARS:
+                parts.append(content[:MAX_SESSION_CHARS] + "...")
             else:
-                parts.append(content[:500])
+                parts.append(content)
         parts.append("")
 
     if not parts:

package/kyp_mem/static/index.html

@@ -1294,8 +1294,8 @@ body.resizing .resize-handle { pointer-events: auto !important; }
 
 .session-item {
   display: flex;
-  align-items: center;
-  padding: 3px 10px;
+  align-items: flex-start;
+  padding: 5px 10px;
   border-radius: var(--radius-sm);
   cursor: pointer;
   font-size: 11px;
@@ -1328,6 +1328,14 @@ body.resizing .resize-handle { pointer-events: auto !important; }
   color: var(--neon-green);
   opacity: 0.5;
   flex-shrink: 0;
+  margin-top: 3px;
+}
+
+.session-item .si-content {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  flex: 1;
 }
 
 .session-item .si-time {
@@ -1336,7 +1344,17 @@ body.resizing .resize-handle { pointer-events: auto !important; }
   color: var(--text-secondary);
 }
 
+.session-item .si-summary {
+  font-size: 10px;
+  color: var(--text-muted);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  line-height: 1.3;
+}
+
 .session-item.active .si-time { color: var(--neon-green); }
+.session-item.active .si-summary { color: var(--text-secondary); }
 
 .session-badge {
   display: inline-flex;
@@ -1573,29 +1591,52 @@ body.resizing .resize-handle { pointer-events: auto !important; }
   color: var(--text-secondary);
 }
 
-/* ============ BACKLINK CONTEXT ============ */
-.rp-item .rp-context {
-  font-size: 10px;
-  color: var(--text-muted);
-  margin-top: 2px;
-  line-height: 1.4;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.rp-item-col {
+/* ============ BACKLINK & UNLINKED ITEMS ============ */
+.rp-link-item {
   display: flex;
-  flex-direction: column;
-  padding: 5px 8px;
+  align-items: center;
+  padding: 4px 8px;
   border-radius: var(--radius-sm);
   cursor: pointer;
   margin-bottom: 1px;
   transition: background 0.1s;
+  gap: 6px;
+}
+
+.rp-link-item:hover { background: var(--bg-hover); }
+
+.rp-link-item .rp-link-icon {
+  font-size: 9px;
+  flex-shrink: 0;
+  opacity: 0.5;
+}
+
+.rp-link-item .rp-link-icon.backlink { color: var(--neon-cyan); }
+.rp-link-item .rp-link-icon.unlinked { color: var(--text-muted); }
+
+.rp-link-item .rp-link-title {
+  font-size: 12px;
+  color: var(--neon-cyan);
+  font-weight: 500;
   overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  transition: all 0.15s;
 }
 
-.rp-item-col:hover { background: var(--bg-hover); }
+.rp-link-item:hover .rp-link-title {
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.rp-link-item.unlinked .rp-link-title {
+  color: var(--text-secondary);
+}
+
+.rp-link-item.unlinked:hover .rp-link-title {
+  color: var(--neon-cyan);
+  text-decoration: underline;
+}
 
 /* ============ TRANSITIONS ============ */
 .fade-in { animation: fadeIn 0.15s ease; }
@@ -2188,10 +2229,8 @@ function renderRightPanel(note) {
     document.getElementById('bl-count').textContent = backlinks.length;
     backlinks.forEach(bl => {
       const item = document.createElement('div');
-      item.className = 'rp-item-col';
-      let html = `<span class="rp-title rp-backlink-title" style="font-size:11px">${bl.title || bl.path || bl}</span>`;
-      if (bl.context) html += `<span class="rp-context">${bl.context}</span>`;
-      item.innerHTML = html;
+      item.className = 'rp-link-item';
+      item.innerHTML = `<span class="rp-link-icon backlink">&#8592;</span><span class="rp-link-title">${bl.title || bl.path || bl}</span>`;
       item.addEventListener('click', () => loadNote(bl.path || bl));
       blList.appendChild(item);
     });
@@ -2244,10 +2283,8 @@ function renderRightPanel(note) {
     document.getElementById('unlinked-count').textContent = unlinked.length;
     unlinked.forEach(u => {
       const item = document.createElement('div');
-      item.className = 'rp-item-col';
-      let html = `<span class="rp-title" style="font-size:11px;color:var(--text-secondary)">${u.title}</span>`;
-      if (u.context) html += `<span class="rp-context">${u.context}</span>`;
-      item.innerHTML = html;
+      item.className = 'rp-link-item unlinked';
+      item.innerHTML = `<span class="rp-link-icon unlinked">&#8776;</span><span class="rp-link-title">${u.title}</span>`;
       item.addEventListener('click', () => loadNote(u.path));
       ulList.appendChild(item);
     });
@@ -2905,6 +2942,23 @@ async function init() {
   `;
 }
 
+// --- Auto-refresh: poll for vault changes ---
+let lastKnownStats = null;
+
+async function pollForChanges() {
+  try {
+    const stats = await fetchJSON('/api/stats');
+    const key = `${stats.notes}:${stats.links}:${stats.tags}`;
+    if (lastKnownStats && lastKnownStats !== key) {
+      await refreshTree();
+      if (currentPath) loadNote(currentPath);
+    }
+    lastKnownStats = key;
+  } catch {}
+}
+
+setInterval(pollForChanges, 3000);
+
 initResize();
 initGraphResize();
 init();

package/kyp_mem/ui.py

@@ -177,12 +177,22 @@ def create_app(vault_path: str = None) -> FastAPI:
                 continue
             if proj not in sessions:
                 sessions[proj] = []
+            summary = ""
+            lines = (note.content or "").split("\n")
+            for i, line in enumerate(lines):
+                if line.strip() == "## Summary":
+                    for j in range(i + 1, len(lines)):
+                        if lines[j].strip() and not lines[j].startswith("#"):
+                            summary = lines[j].strip()
+                            break
+                    break
             sessions[proj].append({
                 "path": path,
                 "title": note.title,
                 "tags": note.tags,
                 "created": note.created,
                 "updated": note.updated,
+                "summary": summary,
             })
         for proj in sessions:
             sessions[proj].sort(key=lambda s: s["path"], reverse=True)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kyp-mem",
-  "version": "0.4.2",
-  "description": "Know Your Project — Persistent knowledge base for AI agents. MCP-powered with wikilinks, backlinks, auto-learning, and neon web UI.",
+  "version": "0.4.4",
+  "description": "Know Your Project — Persistent & Session level knowledge base for AI agents. MCP-powered with wikilinks, backlinks, auto-learning, and neon web UI.",
   "bin": {
     "kyp-mem": "bin/cli.mjs"
   },