@lorekit/cli 1.17.0 → 1.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorekit/cli",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Install the LoreKit shared-memory skill and run health checks for the LoreKit MCP server.",
   "license": "MIT",
   "repository": {

package/src/adapters/claude.mjs

@@ -9,6 +9,7 @@ export const claude = {
       case 'SessionStart':
         return 'read';
       case 'PostToolUse':
+        return 'confirm';
       case 'PostToolUseFailure':
         return 'failure';
       case 'Stop':
@@ -23,11 +24,22 @@ export const claude = {
     return event === 'PostToolUseFailure';
   },
 
+  // Returns true when the PostToolUse event was a successful lorekit memory
+  // write. Claude Code reports MCP tool names as
+  // "mcp__<server-label>__memory_write" (underscores) — we match the suffix
+  // so any server label works. A successful write response always contains
+  // a string `id` field returned by the memory_write RPC.
+  isLoreWrite(toolName, toolResponse) {
+    if (!toolName || !String(toolName).endsWith('memory_write')) return false;
+    return toolResponse != null && typeof toolResponse === 'object' && typeof toolResponse.id === 'string';
+  },
+
   parse(input) {
     return {
       cwd: input.cwd || null,
       sessionId: input.session_id || null,
       toolName: input.tool_name || 'tool',
+      toolInput: input.tool_input || null,
       toolResponse: input.tool_response || null,
       event: input.hook_event_name || null,
     };

package/src/core/lessons.mjs

@@ -174,6 +174,14 @@ function tagsHint(writeScope, { tagsDefault = [], scopeDefaults = null } = {}) {
   return ` Include tags: [${tags.map((t) => JSON.stringify(t)).join(', ')}].`;
 }
 
+// The LoreKit web app URL for the Lore Explorer, pre-filtered to the given scope.
+// Exported so tests can assert the URL shape without re-deriving the encoding.
+export function loreUrl(writeScope) {
+  const base = 'https://lorekit.io/lore';
+  if (!writeScope || writeScope === 'global') return base;
+  return `${base}?scope=${encodeURIComponent(writeScope)}`;
+}
+
 // The retrospective nudge emitted at end-of-turn (one-shot per session).
 // `control` is the resolved control object (optional) — carries tagsDefault and
 // scopeDefaults when the repo/user config defines them.
@@ -182,13 +190,28 @@ export function retrospectiveNudge(scope, control) {
   const hint = tagsHint(writeScope, control);
   const instruction = control && control.hooksInstructions && control.hooksInstructions.Stop
     ? `\n\nProject instruction: ${control.hooksInstructions.Stop}` : '';
+  const url = loreUrl(writeScope);
   return (
     `LoreKit: hit any friction worth remembering — a stuck loop, a repeated ` +
     `failure, a gotcha, a wrong assumption? If so, memory.write to ${writeScope} ` +
-    `as an observation; else skip.${hint}${instruction}`
+    `as an observation; else skip.${hint}${instruction}\n` +
+    `View lore: ${url}`
   );
 }
 
+// Terse confirmation emitted via PostToolUse when a memory.write succeeded.
+// `key` is the lesson key from the tool response (may be null when the response
+// shape doesn't surface it). Includes a deep link to the scope's Lore Explorer
+// page so the user can verify immediately.
+export function writeConfirmation(scope, key) {
+  const writeScope = scope.repoScope || 'global';
+  const keyPart = key ? ` · ${key}` : '';
+  const url = key
+    ? `${loreUrl(writeScope)}&q=${encodeURIComponent(key)}`
+    : loreUrl(writeScope);
+  return `LoreKit: memory saved to ${writeScope}${keyPart}\nView: ${url}`;
+}
+
 // The nudge emitted when a tool failure is detected.
 // `control` is the resolved control object (optional) — carries tagsDefault and
 // scopeDefaults when the repo/user config defines them.

package/src/doctor.mjs

@@ -8,6 +8,9 @@ import {
   SKILLS,
   resolveProjectRoot,
   skillInstallDir,
+  settingsPath,
+  CLAUDE_HOOK_EVENTS,
+  LOREKIT_HOOK_RE,
   readLorekitServer,
   readMcpConfig,
   tokenKind,
@@ -63,6 +66,22 @@ export async function doctor(args) {
     }
   }
 
+  // 2.5. Duplicate-hook detection — warn when the same lorekit hook event is
+  // wired in both the project settings and the global settings. This causes
+  // Claude Code to fire the hook twice per event, producing doubled terminal
+  // output. Common after running `lorekit install` once with --project and
+  // once with --global (or via the marketplace plugin on top of a CLI install).
+  const dupeEvents = detectDuplicateHooks(root);
+  if (dupeEvents.length > 0) {
+    record(
+      'warn',
+      'hooks duplicate',
+      `${dupeEvents.join(', ')} registered in BOTH project and global settings — ` +
+        `Claude Code fires them twice. Remove one scope: ` +
+        `run \`lorekit uninstall --project\` or \`lorekit uninstall --global\`.`,
+    );
+  }
+
   // 3. Resolved control model — which mode, and who decided it.
   const control = loadControl(root, { env: withOverrides(args) });
   record('info', 'memory mode', `${control.mode}  ${c.dim('— decided by ' + control.decidedBy)}`);
@@ -82,8 +101,9 @@ export async function doctor(args) {
   // 5. Scope.
   const scope = deriveScope(root);
   if (scope.hasRemote) {
+    log('');
     record('info', 'read scope', scope.readOrder.join('  →  '));
-    record('info', 'write scope', `${scope.repoScope} (default for "went wrong" memories)`);
+    record('info', 'write scope', `${scope.repoScope} (default write target)`);
   } else {
     record('warn', 'scope', 'no git remote here — memories fall back to global');
   }
@@ -289,6 +309,48 @@ async function deepCheckLocal(store, scope, record) {
   await store.delete({ scope: writeScope, key, force: true });
 }
 
+// Returns the list of CLAUDE_HOOK_EVENTS whose lorekit hook command appears in
+// BOTH the project settings file (.claude/settings.json) and the global one
+// (~/.claude/settings.json). An empty array means no duplicates — healthy.
+function detectDuplicateHooks(root) {
+  const dupes = [];
+  const projectFile = settingsPath(root, 'project');
+  const globalFile = settingsPath(root, 'global');
+
+  let projectHooks = {};
+  let globalHooks = {};
+  try {
+    const cfg = JSON.parse(fs.readFileSync(projectFile, 'utf8'));
+    if (cfg && typeof cfg.hooks === 'object') projectHooks = cfg.hooks;
+  } catch { /* absent or unparseable — treat as empty */ }
+  try {
+    const cfg = JSON.parse(fs.readFileSync(globalFile, 'utf8'));
+    if (cfg && typeof cfg.hooks === 'object') globalHooks = cfg.hooks;
+  } catch { /* absent or unparseable — treat as empty */ }
+
+  for (const event of CLAUDE_HOOK_EVENTS) {
+    const hasInProject = hooksForEvent(projectHooks, event).some((cmd) => LOREKIT_HOOK_RE.test(cmd));
+    const hasInGlobal = hooksForEvent(globalHooks, event).some((cmd) => LOREKIT_HOOK_RE.test(cmd));
+    if (hasInProject && hasInGlobal) dupes.push(event);
+  }
+  return dupes;
+}
+
+// Extract the flat list of hook command strings for one event from a hooks
+// object. Handles the nested-group shape Claude Code uses:
+// { [event]: [ { hooks: [ { type, command } ] } ] }
+function hooksForEvent(hooksObj, event) {
+  const groups = Array.isArray(hooksObj[event]) ? hooksObj[event] : [];
+  const commands = [];
+  for (const group of groups) {
+    const inner = group && Array.isArray(group.hooks) ? group.hooks : [];
+    for (const h of inner) {
+      if (h && typeof h.command === 'string') commands.push(h.command);
+    }
+  }
+  return commands;
+}
+
 function gitTracked(root, dir) {
   // Heuristic: is the store dir ignored by git? If `git check-ignore` names it,
   // it is private; otherwise it will be committed (team-shared).

package/src/hook.mjs

@@ -15,6 +15,7 @@ import {
   failureQuery,
   relevantLessons,
   formatRelevantLessons,
+  writeConfirmation,
 } from './core/lessons.mjs';
 import { isFailure } from './core/failure.mjs';
 import { firstTimeThisSession } from './core/state.mjs';
@@ -109,6 +110,26 @@ async function run(args) {
     return 0;
   }
 
+  if (intent === 'confirm') {
+    // Fire only when a lorekit memory write actually succeeded — the adapter's
+    // isLoreWrite() inspects the tool name and the response shape. Any error
+    // is swallowed (exit 0 — never block the host).
+    try {
+      if (adapter.isLoreWrite && adapter.isLoreWrite(parsed.toolName, parsed.toolResponse)) {
+        // The lesson key comes from the tool INPUT (what the agent sent), not
+        // the response (which only carries id + created_at). toolInput is
+        // populated by the adapter's parse() from the raw hook stdin.
+        const key = (parsed.toolInput && typeof parsed.toolInput.key === 'string')
+          ? parsed.toolInput.key
+          : null;
+        emit(writeConfirmation(scope, key));
+      }
+    } catch {
+      // best-effort — never break the host
+    }
+    return 0;
+  }
+
   if (intent === 'failure') {
     const known = adapter.guaranteedFailure ? adapter.guaranteedFailure(event) : false;
     if (!known && !isFailure(parsed.toolName, parsed.toolResponse)) return 0;

package/src/telemetry.mjs

@@ -32,7 +32,7 @@ import { readLorekitJson } from './config.mjs';
 // (empty in the source tree, so default export stays off until built/injected).
 const DEFAULT_ENDPOINT = 'https://ingress.europe-west4.gcp.dash0-dev.com';
 const DEFAULT_TOKEN = TELEMETRY_TOKEN; // injected from LOREKIT_TELEMETRY_TOKEN at publish
-const DEFAULT_DATASET = 'lorekit-cli';
+const DEFAULT_DATASET = '';
 
 // Flags worth counting (e.g. how many installs are --global). Bounded on
 // purpose: only these booleans are ever attached, never free-form values.