kyp-mem 0.7.3 → 0.8.0

package/bin/cli.mjs

@@ -26,13 +26,25 @@ function run(command, cmdArgs, stdio = "ignore") {
 if (args[0] === "hook") {
   const hookType = args[1];
   const sessionDir = join(homedir(), ".kyp-mem", "sessions");
-  const sessionFile = join(sessionDir, "current.jsonl");
 
   const chunks = [];
   process.stdin.on("data", (chunk) => chunks.push(chunk));
   await new Promise((r) => process.stdin.on("end", r));
   const raw = Buffer.concat(chunks).toString();
 
+  // Partition the activity log per Claude session id. Previously every session
+  // (across all projects) appended to one shared current.jsonl, so concurrent
+  // sessions interleaved and the Stop hook filed the whole batch under whichever
+  // project logged first — leaking foreign summaries into unrelated projects.
+  let sessionId = "";
+  try {
+    sessionId = ((JSON.parse(raw) || {}).session_id || "").toString();
+  } catch (_) {}
+  const safeId = sessionId.replace(/[^A-Za-z0-9_-]/g, "");
+  const sessionFile = safeId
+    ? join(sessionDir, `current-${safeId}.jsonl`)
+    : join(sessionDir, "current.jsonl");
+
   if (hookType === "user-prompt") {
     try {
       const data = JSON.parse(raw);
@@ -59,7 +71,7 @@ if (args[0] === "hook") {
       const input = data.tool_input || {};
       const rawResp = data.tool_response || "";
       const resp = (typeof rawResp === "string" ? rawResp : JSON.stringify(rawResp)).slice(0, 2000);
-      const entry = { ts: new Date().toISOString(), tool, cwd: process.cwd() };
+      const entry = { ts: new Date().toISOString(), tool, cwd: process.env.CLAUDE_PROJECT_DIR || process.cwd() };
 
       if (tool === "Edit" || tool === "Write") {
         entry.file = input.file_path || "";
@@ -93,7 +105,7 @@ if (args[0] === "hook") {
     const py = resolvePython();
     if (py) {
       const [cmd, pre] = py;
-      const r = run(cmd, [...pre, "-m", "kyp_mem.hooks", "stop"], "inherit");
+      const r = run(cmd, [...pre, "-m", "kyp_mem.hooks", "stop", safeId], "inherit");
       process.exit(r.status ?? 0);
     }
     process.exit(0);

package/kyp_mem/cli.py

@@ -49,6 +49,10 @@ def main():
     cfg_parser.add_argument("key", nargs="?", help="Config key (e.g. session_model)")
     cfg_parser.add_argument("value", nargs="?", help="Value to set")
 
+    obj_parser = subparsers.add_parser("objective", help="Get or set a project's objective (injected at session start)")
+    obj_parser.add_argument("project", nargs="?", help="Project name (defaults to current directory name)")
+    obj_parser.add_argument("text", nargs="*", help="Objective text to set (omit to read the current objective)")
+
     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")
@@ -79,6 +83,8 @@ def main():
         _run_install_hooks(global_config=args.global_config, remove=args.remove)
     elif args.command == "config":
         _run_config(args.key, args.value)
+    elif args.command == "objective":
+        _run_objective(args.project, " ".join(args.text).strip())
     elif args.command == "uninstall":
         _run_uninstall(purge=args.purge)
     elif args.command == "doctor":
@@ -460,6 +466,39 @@ def _run_config(key, value):
     print(f"  {G}✓{R} {key} = {value}")
 
 
+def _run_objective(project, text):
+    from .config import get_vault_path
+    from .vault import Vault
+
+    project = project or Path.cwd().name
+    vault = Vault(get_vault_path())
+    path = f"{project}/Objective.md"
+
+    if not text:
+        note = vault.read(path)
+        print()
+        print(f"  {C}KYP-MEM{R} — Objective for {G}{project}{R}")
+        print()
+        if not note:
+            print(f"  {Y}(not set){R}")
+            print(f"  {D}  Set one: kyp-mem objective {project} \"<your goal>\"{R}")
+        else:
+            content = note.content.strip()
+            lines = content.split("\n")
+            if lines and lines[0].lstrip().startswith("# "):
+                content = "\n".join(lines[1:]).strip()
+            print(f"  {content}")
+        print()
+        return
+
+    content = f"# Objective\n\n{text}\n"
+    vault.write_note(path, content, ["objective", project.lower().replace(" ", "-")], {})
+    print()
+    print(f"  {G}✓{R} Objective saved for {G}{project}{R} ({path})")
+    print(f"  {D}  Injected at every session start.{R}")
+    print()
+
+
 def _run_stats():
     from .config import get_vault_path
     from .vault import Vault

package/kyp_mem/hooks.py

@@ -10,6 +10,37 @@ from pathlib import Path
 SESSION_DIR = Path.home() / ".kyp-mem" / "sessions"
 CURRENT_SESSION = SESSION_DIR / "current.jsonl"
 
+
+def _session_file(session_id):
+    """Per-Claude-session activity log path.
+
+    Each Claude session gets its own ``current-<session_id>.jsonl`` so that
+    concurrent sessions in different projects never share one file. Falls back
+    to the legacy shared ``current.jsonl`` when no session id is available.
+    """
+    if session_id:
+        safe = "".join(c for c in str(session_id) if c.isalnum() or c in "_-")
+        if safe:
+            return SESSION_DIR / f"current-{safe}.jsonl"
+    return CURRENT_SESSION
+
+
+def _prune_stale_logs(max_age_days=3):
+    """Remove orphaned activity logs left by sessions that never fired Stop
+    (crashes, kills) plus the legacy shared current.jsonl once it goes idle."""
+    import time
+
+    cutoff = time.time() - max_age_days * 86400
+    try:
+        for f in SESSION_DIR.glob("current*.jsonl"):
+            try:
+                if f.stat().st_mtime < cutoff:
+                    f.unlink(missing_ok=True)
+            except OSError:
+                pass
+    except Exception:
+        pass
+
 MIN_ACTIONS = 5
 CHARS_PER_TOKEN = 4
 
@@ -114,8 +145,42 @@ def _build_stats_line(project_name, injected_chars, session_ids):
         return None
 
 
+def _objective_note_path(project_name):
+    """Canonical vault path for a project's objective note."""
+    return f"{project_name}/Objective.md"
+
+
+def _find_objective_path(vault, project_name):
+    """Case-insensitive lookup of the objective note (vault casing may differ
+    from the cwd basename on case-insensitive filesystems)."""
+    target = f"{project_name}/objective.md".lower()
+    for p in vault.index.notes:
+        if p.lower() == target:
+            return p
+    return None
+
+
+def _read_objective(vault, project_name):
+    """Return the objective text for a project, or None if not set.
+
+    Strips an optional leading ``# ...`` heading so only the objective body
+    is surfaced.
+    """
+    path = _find_objective_path(vault, project_name)
+    if not path:
+        return None
+    note = vault.read(path)
+    if not note:
+        return None
+    lines = note.content.strip().split("\n")
+    if lines and lines[0].lstrip().startswith("# "):
+        lines = lines[1:]
+    text = "\n".join(lines).strip()
+    return text or None
+
+
 def handle_session_start():
-    """Inject recent session memory into the conversation at session start."""
+    """Inject the project objective and recent session memory at session start."""
     sys.stdin.read()
     if _is_subprocess():
         return
@@ -123,43 +188,76 @@ def handle_session_start():
     cwd = os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
     project_name = Path(cwd).name
 
+    _prune_stale_logs()
+
     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
+        # Match case-insensitively: the project dir may be stored in the vault
+        # with different casing than the cwd basename (e.g. on case-insensitive
+        # filesystems "KYP-MEM" and "kyp-mem" are the same directory).
+        prefix = f"{project_name}/".lower()
+        project_notes = [p for p in vault.index.notes if p.lower().startswith(prefix)]
+
+        objective = _read_objective(vault, project_name)
 
         sessions = sorted(
-            (p for p in project_notes if "/Sessions/" in p),
+            (p for p in project_notes if "/sessions/" in p.lower()),
             reverse=True,
-        )[:3]
-        if not sessions:
-            return
+        )[:10]
+
+        # Nothing to say: no objective to surface, no objective to request
+        # (project is already known but sessions just haven't been captured),
+        # and no sessions. Only stay silent when this is an established project
+        # with an objective but zero sessions — otherwise we always at least
+        # surface or request the objective.
+        if not objective and not project_notes and not sessions:
+            # Brand-new / unknown directory: still ask for an objective so the
+            # project starts with a clear goal.
+            pass
 
-        parts = [f"# [kyp-mem] {project_name} — Recent Sessions"]
+        parts = [f"# [kyp-mem] {project_name} — Session Context"]
         parts.append(f"Use `kyp_search` or `kyp_project_context` for architecture/project knowledge on demand.\n")
 
-        parts.append(f"## Last {len(sessions)} Sessions")
-        for sp in sessions:
-            note = vault.read(sp)
-            if not note:
-                continue
-            parts.append(f"### {note.title}")
-            summary = _extract_session_summary(note.content)
-            parts.append(summary)
+        # --- Objective (always first) ---
+        if objective:
+            parts.append("## 🎯 Objective")
+            parts.append(objective)
             parts.append("")
+        else:
+            parts.append("## 🎯 Objective — NOT SET")
+            parts.append(
+                f"No objective is recorded for **{project_name}**. Before anything else, "
+                "ask the user: **\"What is the main objective / goal for this project?\"** "
+                "When they answer, save it by calling "
+                f"`kyp_objective_set(project=\"{project_name}\", objective=\"...\")` "
+                f"(or `kyp_write(\"{project_name}/Objective.md\", ...)`). "
+                "Keep your work aligned to this objective every session."
+            )
+            parts.append("")
+
+        # --- Recent sessions ---
+        if sessions:
+            parts.append(f"## Last {len(sessions)} Sessions")
+            for sp in sessions:
+                note = vault.read(sp)
+                if not note:
+                    continue
+                parts.append(f"### {note.title}")
+                summary = _extract_session_summary(note.content)
+                parts.append(summary)
+                parts.append("")
 
-        session_ids = {Path(sp).stem for sp in sessions}
-        stats_line = _build_stats_line(project_name, len("\n".join(parts)), session_ids)
-        if stats_line:
-            parts.append(stats_line)
+            session_ids = {Path(sp).stem for sp in sessions}
+            stats_line = _build_stats_line(project_name, len("\n".join(parts)), session_ids)
+            if stats_line:
+                parts.append(stats_line)
 
         parts.append("")
-        parts.append("**CRITICAL: Your FIRST response to the user MUST be displaying the session summaries below. Do NOT skip this. Do NOT wait for user input. Display them immediately, formatted cleanly, before doing anything else.**")
+        parts.append("**CRITICAL: Your FIRST response to the user MUST surface this context — display the session summaries above (if any) and the objective. If the objective is NOT SET, ask the user for it as instructed. Do this immediately, formatted cleanly, before anything else.**")
 
         output = "\n".join(parts)
 
@@ -193,7 +291,7 @@ def handle_user_prompt():
     }
 
     SESSION_DIR.mkdir(parents=True, exist_ok=True)
-    with open(CURRENT_SESSION, "a") as f:
+    with open(_session_file(data.get("session_id", "")), "a") as f:
         f.write(json.dumps(entry) + "\n")
 
 
@@ -255,7 +353,7 @@ def handle_post_tool_use():
         return
 
     SESSION_DIR.mkdir(parents=True, exist_ok=True)
-    with open(CURRENT_SESSION, "a") as f:
+    with open(_session_file(data.get("session_id", "")), "a") as f:
         f.write(json.dumps(entry) + "\n")
 
 
@@ -513,13 +611,14 @@ Raw session data:
         return None
 
 
-def handle_stop():
-    if _is_subprocess() or not CURRENT_SESSION.exists():
+def handle_stop(session_id=""):
+    session_file = _session_file(session_id)
+    if _is_subprocess() or not session_file.exists():
         return
 
-    text = CURRENT_SESSION.read_text().strip()
+    text = session_file.read_text().strip()
     if not text:
-        CURRENT_SESSION.unlink(missing_ok=True)
+        session_file.unlink(missing_ok=True)
         return
 
     entries = []
@@ -530,12 +629,12 @@ def handle_stop():
             continue
 
     if not entries:
-        CURRENT_SESSION.unlink(missing_ok=True)
+        session_file.unlink(missing_ok=True)
         return
 
     write_actions = [e for e in entries if e.get("action") in ("edit", "create", "command")]
     if len(write_actions) < MIN_ACTIONS:
-        CURRENT_SESSION.unlink(missing_ok=True)
+        session_file.unlink(missing_ok=True)
         return
 
     project_dir = entries[0].get("cwd", "unknown")
@@ -691,8 +790,8 @@ def handle_stop():
         pass
 
     # Delete session file BEFORE summarization so the spawned claude subprocess
-    # doesn't pollute it via hooks writing back into current.jsonl
-    CURRENT_SESSION.unlink(missing_ok=True)
+    # doesn't pollute it via hooks writing back into the session log
+    session_file.unlink(missing_ok=True)
 
     # Try Claude summarization, fall back to raw sections
     summarized = _summarize_with_claude(raw_note, project_name)
@@ -765,7 +864,8 @@ def handle_stop():
 
 def main():
     if len(sys.argv) > 1 and sys.argv[1] == "stop":
-        handle_stop()
+        session_id = sys.argv[2] if len(sys.argv) > 2 else ""
+        handle_stop(session_id)
     else:
         raw = sys.stdin.read().strip()
         if not raw:
@@ -775,7 +875,7 @@ def main():
         except json.JSONDecodeError:
             return
         if "stop_reason" in data:
-            handle_stop()
+            handle_stop(data.get("session_id", ""))
 
 
 if __name__ == "__main__":

package/kyp_mem/server.py

@@ -22,6 +22,7 @@ YOU MUST FOLLOW THESE INSTRUCTIONS when kyp-mem tools are available.
 2. Call `kyp_project_context(project)` to load the project's knowledge base, notes, and recent session summaries.
 3. If no project exists yet, call `kyp_project_context` anyway — if it returns empty, ask the user if you should create one.
 4. Use the returned context to ground yourself: understand architecture, known bugs, past decisions, and what was done in recent sessions. Do NOT ask the user questions that are already answered in the project context.
+5. Check the project objective with `kyp_objective_get(project)`. If none is set, ask the user for the project's main goal and save it with `kyp_objective_set(project, objective)`. Keep your work aligned to this objective.
 
 ### DURING WORK — WHEN TO SEARCH SESSIONS
 Call `kyp_session_search(query)` when:
@@ -342,6 +343,31 @@ def kyp_sessions(project: str = "", limit: int = 10) -> str:
     return "\n".join(lines)
 
 
+@mcp.tool()
+def kyp_objective_get(project: str) -> str:
+    """Get the recorded objective / main goal for a project. The objective is injected at every session start. Returns a not-set message if none exists yet."""
+    note = vault.read(f"{project}/Objective.md")
+    if not note:
+        return f"No objective set for '{project}'. Ask the user for the project's main goal, then call kyp_objective_set."
+    content = note.content.strip()
+    lines = content.split("\n")
+    if lines and lines[0].lstrip().startswith("# "):
+        content = "\n".join(lines[1:]).strip()
+    return content or f"No objective set for '{project}'."
+
+
+@mcp.tool()
+def kyp_objective_set(project: str, objective: str) -> str:
+    """Set (or replace) the objective / main goal for a project. This is injected into every future session start so work stays aligned. Call this once the user tells you what the project is for."""
+    objective = objective.strip()
+    if not objective:
+        return "Objective text is empty — nothing saved."
+    path = f"{project}/Objective.md"
+    content = f"# Objective\n\n{objective}\n"
+    vault.write_note(path, content, ["objective", project.lower().replace(" ", "-")], {})
+    return f"Objective saved for '{project}' ({path}). It will be injected at every session start."
+
+
 @mcp.tool()
 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."""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kyp-mem",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "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"

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kyp-mem"
-version = "0.7.3"
+version = "0.8.0"
 description = "Know Your Project — Persistent knowledge base for AI agents. MCP-powered with wikilinks, backlinks, auto-learning, and neon web UI."
 readme = "README.md"
 license = {text = "MIT"}