memorix 1.2.2 → 1.2.4

package/src/git/hooks-path.ts

@@ -1,85 +1,85 @@
-/**
- * Git hooks path resolver — worktree-safe.
- *
- * In a normal repo:   .git is a directory  → hooks at .git/hooks/
- * In a git worktree:  .git is a FILE containing "gitdir: /path/to/actual/git/dir"
- *                     → hooks at that resolved path + /hooks/
- *
- * This utility ensures all hook install/uninstall/check operations
- * work correctly in both scenarios.
- */
-
-import { existsSync, readFileSync, statSync, mkdirSync } from 'node:fs';
-import path from 'node:path';
-
-/**
- * Resolve the actual .git directory path, following worktree indirection.
- *
- * @param projectRoot - The root of the working tree (where .git lives)
- * @returns Absolute path to the real git dir, or null if no .git found
- */
-export function resolveGitDir(projectRoot: string): string | null {
-  const dotGit = path.join(projectRoot, '.git');
-
-  if (!existsSync(dotGit)) return null;
-
-  const stat = statSync(dotGit);
-
-  if (stat.isDirectory()) {
-    // Normal repo — .git is a directory
-    return dotGit;
-  }
-
-  if (stat.isFile()) {
-    // Worktree — .git is a file: "gitdir: /path/to/actual/git/dir"
-    try {
-      const content = readFileSync(dotGit, 'utf-8').trim();
-      const match = content.match(/^gitdir:\s*(.+)$/);
-      if (match) {
-        const gitdir = match[1].trim();
-        // Resolve relative paths against the project root
-        const resolved = path.isAbsolute(gitdir)
-          ? gitdir
-          : path.resolve(projectRoot, gitdir);
-        if (existsSync(resolved)) {
-          return resolved;
-        }
-      }
-    } catch {
-      // Unreadable .git file — fall through
-    }
-  }
-
-  return null;
-}
-
-/**
- * Resolve the hooks directory for a project (read-only — does NOT create directories).
- * Handles both normal repos and git worktrees.
- *
- * @param projectRoot - The root of the working tree
- * @returns Object with hooksDir and hookPath for post-commit, or null if no .git found
- */
-export function resolveHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
-  const gitDir = resolveGitDir(projectRoot);
-  if (!gitDir) return null;
-
-  const hooksDir = path.join(gitDir, 'hooks');
-
-  return {
-    hooksDir,
-    hookPath: path.join(hooksDir, 'post-commit'),
-  };
-}
-
-/**
- * Resolve hooks directory AND ensure it exists on disk.
- * Use this only in write paths (hook install / autoHook).
- */
-export function ensureHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
-  const resolved = resolveHooksDir(projectRoot);
-  if (!resolved) return null;
-
-  mkdirSync(resolved.hooksDir, { recursive: true });
-  return resolved;
-}
+/**
+ * Git hooks path resolver — worktree-safe.
+ *
+ * In a normal repo:   .git is a directory  → hooks at .git/hooks/
+ * In a git worktree:  .git is a FILE containing "gitdir: /path/to/actual/git/dir"
+ *                     → hooks at that resolved path + /hooks/
+ *
+ * This utility ensures all hook install/uninstall/check operations
+ * work correctly in both scenarios.
+ */
+
+import { existsSync, readFileSync, statSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Resolve the actual .git directory path, following worktree indirection.
+ *
+ * @param projectRoot - The root of the working tree (where .git lives)
+ * @returns Absolute path to the real git dir, or null if no .git found
+ */
+export function resolveGitDir(projectRoot: string): string | null {
+  const dotGit = path.join(projectRoot, '.git');
+
+  if (!existsSync(dotGit)) return null;
+
+  const stat = statSync(dotGit);
+
+  if (stat.isDirectory()) {
+    // Normal repo — .git is a directory
+    return dotGit;
+  }
+
+  if (stat.isFile()) {
+    // Worktree — .git is a file: "gitdir: /path/to/actual/git/dir"
+    try {
+      const content = readFileSync(dotGit, 'utf-8').trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitdir = match[1].trim();
+        // Resolve relative paths against the project root
+        const resolved = path.isAbsolute(gitdir)
+          ? gitdir
+          : path.resolve(projectRoot, gitdir);
+        if (existsSync(resolved)) {
+          return resolved;
+        }
+      }
+    } catch {
+      // Unreadable .git file — fall through
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve the hooks directory for a project (read-only — does NOT create directories).
+ * Handles both normal repos and git worktrees.
+ *
+ * @param projectRoot - The root of the working tree
+ * @returns Object with hooksDir and hookPath for post-commit, or null if no .git found
+ */
+export function resolveHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
+  const gitDir = resolveGitDir(projectRoot);
+  if (!gitDir) return null;
+
+  const hooksDir = path.join(gitDir, 'hooks');
+
+  return {
+    hooksDir,
+    hookPath: path.join(hooksDir, 'post-commit'),
+  };
+}
+
+/**
+ * Resolve hooks directory AND ensure it exists on disk.
+ * Use this only in write paths (hook install / autoHook).
+ */
+export function ensureHooksDir(projectRoot: string): { hooksDir: string; hookPath: string } | null {
+  const resolved = resolveHooksDir(projectRoot);
+  if (!resolved) return null;
+
+  mkdirSync(resolved.hooksDir, { recursive: true });
+  return resolved;
+}

package/src/hooks/handler.ts

@@ -22,6 +22,9 @@ import { detectBestPattern, patternToObservationType } from './pattern-detector.
 import { isSignificantKnowledge, isRetrievedResult, isTrivialCommand } from './significance-filter.js';
 import type { AgentName, HookEvent, HookOutput, NormalizedHookInput } from './types.js';
 
+type HookInjectionMode = 'full' | 'minimal' | 'silent';
+type HookContextTarget = 'hook-session-start' | 'hook-user-prompt';
+
 // ─── Constants ───
 
 /** Observation type → emoji mapping (single source of truth) */
@@ -282,16 +285,117 @@ function buildObservation(
 
 // ─── Session Start Handler ───
 
+async function getHookInjectionMode(input: NormalizedHookInput): Promise<HookInjectionMode> {
+  try {
+    const { getBehaviorConfig } = await import('../config/behavior.js');
+    return getBehaviorConfig({ projectRoot: input.cwd || undefined }).sessionInject;
+  } catch {
+    return 'minimal';
+  }
+}
+
+/**
+ * Assemble the one bounded project brief shared by hook delivery points.
+ * Hooks never retrieve a transcript: this returns only the normal Workset.
+ */
+async function buildHookProjectContext(
+  input: NormalizedHookInput,
+  task: string,
+  target: HookContextTarget,
+): Promise<{ prompt: string; hasContinuation: boolean } | null> {
+  try {
+    const { detectProject } = await import('../project/detector.js');
+    const { getProjectDataDir } = await import('../store/persistence.js');
+    const { initObservationStore, getObservationStore: getStore } = await import('../store/obs-store.js');
+    const { initMiniSkillStore } = await import('../store/mini-skill-store.js');
+    const { initSessionStore } = await import('../store/session-store.js');
+    const { initAliasRegistry, registerAlias } = await import('../project/aliases.js');
+    const { MaintenanceTargetStore } = await import('../runtime/maintenance-targets.js');
+    const { buildAutoProjectContext, formatAutoProjectContextPrompt } = await import('../codegraph/auto-context.js');
+    const { filterReadableObservations } = await import('../memory/visibility.js');
+
+    const rawProject = detectProject(input.cwd || process.cwd());
+    if (!rawProject) return null;
+    const dataDir = await getProjectDataDir(rawProject.id);
+
+    initAliasRegistry(dataDir);
+    const canonicalId = await registerAlias(rawProject);
+    new MaintenanceTargetStore(dataDir).register({
+      projectId: canonicalId,
+      projectRoot: rawProject.rootPath,
+      dataDir,
+    });
+    await initObservationStore(dataDir);
+    await initMiniSkillStore(dataDir);
+    await initSessionStore(dataDir);
+    const activeObservations = filterReadableObservations(
+      await getStore().loadByProject(canonicalId, { status: 'active' }),
+      { projectId: canonicalId },
+    );
+    const context = await buildAutoProjectContext({
+      project: { ...rawProject, id: canonicalId },
+      dataDir,
+      observations: activeObservations,
+      task,
+      refresh: 'auto',
+      reader: { projectId: canonicalId },
+      continuation: 'always',
+      enqueueRefresh: () => import('../runtime/lifecycle.js').then(({ enqueueCodegraphRefresh }) => {
+        enqueueCodegraphRefresh({
+          dataDir,
+          projectId: canonicalId,
+          source: target === 'hook-user-prompt' ? 'hook-user-prompt' : 'hook-session-start',
+          maxFiles: 5_000,
+        });
+      }),
+      deliveryTarget: target,
+    });
+
+    return {
+      prompt: formatAutoProjectContextPrompt(context),
+      hasContinuation: Boolean(
+        context.continuation?.previousSession || (context.continuation?.memories.length ?? 0) > 0,
+      ),
+    };
+  } catch (error) {
+    // A context hint must never interrupt the host's turn. The structured
+    // error is intentionally kept in stderr for hook diagnostics.
+    console.error('[memorix] hook context failed:', (error as Error)?.message ?? error);
+    return null;
+  }
+}
+
+/**
+ * Claude Code ignores SessionStart systemMessage as model context. Its official
+ * UserPromptSubmit output accepts additionalContext, so explicit continuation
+ * requests are delivered there instead of relying on a rules-file suggestion.
+ */
+async function buildClaudeContinuationPromptContext(input: NormalizedHookInput): Promise<string | undefined> {
+  if (input.agent !== 'claude' || input.event !== 'user_prompt' || !input.userPrompt?.trim()) {
+    return undefined;
+  }
+
+  const { isContinuationTask } = await import('../codegraph/task-lens.js');
+  if (!isContinuationTask(input.userPrompt)) return undefined;
+
+  if (await getHookInjectionMode(input) === 'silent') return undefined;
+
+  const context = await buildHookProjectContext(input, input.userPrompt, 'hook-user-prompt');
+  if (!context?.hasContinuation) return undefined;
+
+  return [
+    'Memorix prepared a bounded prior-work brief for this explicit continuation request.',
+    'Treat it as background context; current code wins. Use it before broad Git or file-history archaeology.',
+    '',
+    context.prompt,
+  ].join('\n');
+}
+
 async function handleSessionStart(input: NormalizedHookInput): Promise<{
   observation: ReturnType<typeof buildObservation> | null;
   output: HookOutput;
 }> {
-  // Check behavior config for session injection level
-  let injectMode: 'full' | 'minimal' | 'silent' = 'minimal';
-  try {
-    const { getBehaviorConfig } = await import('../config/behavior.js');
-    injectMode = getBehaviorConfig().sessionInject;
-  } catch { /* default to minimal */ }
+  const injectMode = await getHookInjectionMode(input);
 
   if (injectMode === 'silent') {
     return { observation: null, output: { continue: true } };
@@ -299,55 +403,8 @@ async function handleSessionStart(input: NormalizedHookInput): Promise<{
 
   let contextSummary = '';
   if (injectMode === 'full') {
-    try {
-      const { detectProject } = await import('../project/detector.js');
-      const { getProjectDataDir } = await import('../store/persistence.js');
-      const { initObservationStore, getObservationStore: getStore } = await import('../store/obs-store.js');
-      const { initMiniSkillStore } = await import('../store/mini-skill-store.js');
-      const { initSessionStore } = await import('../store/session-store.js');
-      const { initAliasRegistry, registerAlias } = await import('../project/aliases.js');
-      const { MaintenanceTargetStore } = await import('../runtime/maintenance-targets.js');
-      const { buildAutoProjectContext, formatAutoProjectContextPrompt } = await import('../codegraph/auto-context.js');
-      const { filterReadableObservations } = await import('../memory/visibility.js');
-
-      const rawProject = detectProject(input.cwd || process.cwd());
-      if (!rawProject) throw new Error('No .git found');
-      const dataDir = await getProjectDataDir(rawProject.id);
-
-      initAliasRegistry(dataDir);
-      const canonicalId = await registerAlias(rawProject);
-      new MaintenanceTargetStore(dataDir).register({
-        projectId: canonicalId,
-        projectRoot: rawProject.rootPath,
-        dataDir,
-      });
-      await initObservationStore(dataDir);
-      await initMiniSkillStore(dataDir);
-      await initSessionStore(dataDir);
-      const activeObservations = filterReadableObservations(
-        await getStore().loadByProject(canonicalId, { status: 'active' }),
-        { projectId: canonicalId },
-      );
-      const context = await buildAutoProjectContext({
-        project: { ...rawProject, id: canonicalId },
-        dataDir,
-        observations: activeObservations,
-        refresh: 'auto',
-        enqueueRefresh: () => import('../runtime/lifecycle.js').then(({ enqueueCodegraphRefresh }) => {
-            enqueueCodegraphRefresh({
-              dataDir,
-              projectId: canonicalId,
-              source: 'hook-session-start',
-              maxFiles: 5_000,
-            });
-          }),
-        deliveryTarget: 'hook-session-start',
-      });
-      contextSummary = `\n\n${formatAutoProjectContextPrompt(context)}`;
-    } catch (sessErr) {
-      // Diagnostic log — session start context injection failed
-      console.error('[memorix] session start context failed:', (sessErr as Error)?.message ?? sessErr);
-    }
+    const context = await buildHookProjectContext(input, 'Continue the current task.', 'hook-session-start');
+    if (context) contextSummary = `\n\n${context.prompt}`;
   }
 
   // Build system message based on inject mode
@@ -378,6 +435,10 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   output: HookOutput;
 }> {
   const defaultOutput: HookOutput = { continue: true };
+  const continuationMessage = await buildClaudeContinuationPromptContext(input);
+  const output = continuationMessage
+    ? { ...defaultOutput, systemMessage: continuationMessage }
+    : defaultOutput;
 
   // ─── Session lifecycle (special handling) ───
   if (input.event === 'session_start') {
@@ -386,7 +447,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   if (input.event === 'session_end') {
     const endContent = extractContent(input);
     if (endContent.length < 50) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
     const draft = buildObservation(input, endContent, 'unknown');
     const admission = assessHookAdmission({
@@ -399,13 +460,13 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
       observation: admission.action === 'store'
         ? buildObservation(input, endContent, 'unknown', admission)
         : null,
-      output: defaultOutput,
+      output,
     };
   }
   if (input.event === 'post_compact') {
     // Post-compaction: acknowledge the event, no observation needed.
     // The real value is the side-effect (runHook pipe) already handled by the plugin.
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // ─── Classify & extract ───
@@ -415,7 +476,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
 
   // Never-store category (memorix's own tools)
   if (policy.store === 'never') {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // ─── Significance Filter (Cipher-style noise rejection) ───
@@ -423,13 +484,13 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   if (category === 'command' && input.command) {
     const realCmd = extractRealCommand(input.command);
     if (isTrivialCommand(realCmd)) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
   }
 
   // Skip retrieved/search results (prevent memory pollution)
   if (isRetrievedResult(content)) {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // Minimum length gate
@@ -437,7 +498,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
     ? MIN_PROMPT_LENGTH
     : policy.minLength;
   if (content.length < minLen) {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
 
   // User prompts & AI responses are direct interaction — check significance
@@ -450,7 +511,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
   if (effectiveStore !== 'always') {
     const significance = isSignificantKnowledge(content);
     if (!significance.isSignificant) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
   }
 
@@ -459,14 +520,14 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
     const pattern = detectBestPattern(content);
     const significance = isSignificantKnowledge(content);
     if (!pattern && content.length < 200 && !significance.isSignificant) {
-      return { observation: null, output: defaultOutput };
+      return { observation: null, output };
     }
   }
 
   // Cooldown (per-file or per-command, not per-tool-category)
   const cooldownKey = buildCooldownKey(input, content);
   if (isInCooldown(cooldownKey)) {
-    return { observation: null, output: defaultOutput };
+    return { observation: null, output };
   }
   markTriggered(cooldownKey);
 
@@ -481,7 +542,7 @@ async function handleHookEventCore(input: NormalizedHookInput): Promise<{
     observation: admission.action === 'store'
       ? buildObservation(input, content, category, admission)
       : null,
-    output: defaultOutput,
+    output,
   };
 }
 

package/src/hooks/installers/index.ts

@@ -1210,17 +1210,18 @@ function getAgentRulesContent(agent?: AgentName, scope: 'project' | 'global' = '
     '',
     '## Start with Memory Autopilot',
     '',
-    `Default first step for non-trivial coding work: call \x60memorix_project_context\x60 with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
+    `Default first step for non-trivial coding work: call \x60memorix_project_context\x60 with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). When the task is continuing prior work, the same brief also includes a bounded prior-work projection. Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
     '',
-    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select \x60memorix_project_context\x60 first. Run \x60memorix context --task "<task>"\x60 only after MCP is unavailable, disabled, or not discoverable, and pass the user\'s real task text. Do not skip memory, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
+    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select \x60memorix_project_context\x60 first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: \x60memorix resume "<task>" --json\x60. For a new task, use \x60memorix context "<task>" --json\x60 instead. The absence of \x60.memorix\x60 or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
     '',
-    'Use \x60memorix_context_pack\x60 when you need structured refs and freshness for code-bound memories.',
+    'After a successful \x60memorix_project_context\x60 result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use \x60memorix_context_pack\x60, \x60memorix_search\x60, or \x60memorix_detail\x60 only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in \x60purpose\x60 when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.',
+    'If the user asks for read-only work or says not to modify files, do not call \x60memorix_store\x60 just to record an assessment. Store only when the user explicitly asks to preserve it.',
     '',
     '## When to search memory',
     '',
     'Use \x60memorix_graph_context\x60 for explicit memory graph questions or broad graph overview after the autopilot brief is not enough.',
     '',
-    `Use \x60memorix_search\x60 when prior ${contextNoun} context would help — for example:`,
+    `Use \x60memorix_search\x60 when prior ${contextNoun} context would help and the Autopilot brief did not already answer the question — for example:`,
     '- The user asks about a past decision, bug, or change',
     '- You need to understand why something was designed a certain way',
     "- You're continuing work that started in a previous session",

package/src/hooks/official-skills.ts

@@ -31,7 +31,8 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '| Situation | Prefer | CLI fallback |',
       '|---|---|---|',
-      '| Starting or continuing a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context --task "<task>"` |',
+      '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --json` |',
+      '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --json` |',
       '| Need structured refs/freshness for code-bound memories | `memorix_context_pack` | `memorix codegraph context-pack --task "<topic>"` |',
       '| Explicit memory graph question | `memorix_graph_context` | `memorix memory graph-context --query "<topic>"` |',
       '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
@@ -44,9 +45,10 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '- Default first step for non-trivial coding work: call `memorix_project_context` before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Pass the user\'s actual task so Memorix can choose a bugfix, feature, release, onboarding, refactor, docs, test, or general brief. Start by reading its suggested files.',
       '- In Claude Code headless/print-mode, an initial MCP `pending` status is not a failure by itself. Prefer MCP first: use the client\'s tool discovery/dynamic loading to find `memorix_project_context` when it is not in the first visible tool list.',
-      '- Run `memorix context --task "<task>"` from the shell only after MCP is unavailable, disabled, or not discoverable, and pass the user\'s real task text. Do not skip memory, wait indefinitely on `pending`, or hand-write tool-call syntax.',
-      '- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer.',
-      '- Fetch detail before relying on a specific memory.',
+      '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --json` instead. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+      '- After a successful `memorix_project_context`, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use Context Pack, search, or detail only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.',
+      '- If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.',
+      '- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer. Fetch detail only for a result you still need after the brief.',
       '- Treat current code-bound memory as a map. Treat stale, suspect, or unbound memory as a lead that must be verified against the current code.',
       '- Skip memory lookup for greetings, tiny one-off edits, or questions fully answered by the current file.',
       '- If a fresh project has no memories, proceed normally and do not repeat the same empty search in the same turn.',