memorix 1.7.3 → 1.8.0

package/src/dashboard/server.ts

@@ -22,10 +22,13 @@ import { loadDotenv } from '../config/dotenv-loader.js';
 import { resetDotenv } from '../config/dotenv-loader.js';
 import { initProjectRoot } from '../config/yaml-loader.js';
 import { clearProjectRoot } from '../config/yaml-loader.js';
+import { getResolvedConfig } from '../config/resolved-config.js';
 import { scopeKnowledgeGraphToProject } from '../memory/graph-scope.js';
 import { projectObservationRetention, summarizeRetentionProjections } from '../memory/retention.js';
 import { canManageObservation, filterReadableObservations } from '../memory/visibility.js';
 import type { Observation } from '../types.js';
+import { EvidenceCardStore } from '../store/evidence-store.js';
+import { MemoryFeedbackStore } from '../memory/feedback.js';
 import {
     DashboardMaintenanceError,
     executeCleanup,
@@ -37,6 +40,7 @@ import {
     previewDeduplicate,
     previewRetentionArchive,
 } from './maintenance.js';
+import { resolveDashboardKeySource } from './config-provenance.js';
 
 // MIME types for static file serving
 const MIME_TYPES: Record<string, string> = {
@@ -326,6 +330,22 @@ async function handleApi(
                 break;
             }
 
+            case '/evidence': {
+                const observations = filterDashboardObservations(
+                    await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }),
+                    effectiveProjectId,
+                );
+                const evidenceStore = new EvidenceCardStore();
+                await evidenceStore.init(effectiveDataDir);
+                evidenceStore.syncObservations(observations);
+                const query = url.searchParams.get('q') || '';
+                const limit = Number(url.searchParams.get('limit') || 20);
+                const cards = evidenceStore.list(effectiveProjectId, { limit: Math.min(100, Math.max(1, limit)) })
+                    .filter((card) => !query || [card.title, card.summary, card.sourceRef, card.locator ?? ''].join(' ').toLowerCase().includes(query.toLowerCase()));
+                sendJson(res, { cards, projectId: effectiveProjectId });
+                break;
+            }
+
             case '/sessions': {
                 const allSessions = await getSessionStore().loadAll();
                 const sessions = filterByProject(allSessions as Array<{ projectId?: string }>, effectiveProjectId);
@@ -381,10 +401,15 @@ async function handleApi(
                 }));
 
                 const retentionReferenceTime = new Date(now);
+                const feedback = new MemoryFeedbackStore();
+                await feedback.init(effectiveDataDir).catch(() => undefined);
                 const retention = summarizeRetentionProjections(
                     observations
                         .filter((observation) => observation.type !== 'probe')
-                        .map((observation) => projectObservationRetention(observation, { referenceTime: retentionReferenceTime })),
+                        .map((observation) => projectObservationRetention(observation, {
+                            referenceTime: retentionReferenceTime,
+                            feedback: feedback.getState(effectiveProjectId, 'observation', String(observation.id)),
+                        })),
                 );
                 const retentionSummary = {
                     active: retention.active,
@@ -489,11 +514,16 @@ async function handleApi(
                 );
 
                 const referenceTime = new Date();
+                const feedback = new MemoryFeedbackStore();
+                await feedback.init(effectiveDataDir).catch(() => undefined);
                 const rows = observations
                     .filter((observation) => observation.type !== 'probe')
                     .map((observation) => ({
                         observation,
-                        retention: projectObservationRetention(observation, { referenceTime }),
+                        retention: projectObservationRetention(observation, {
+                            referenceTime,
+                            feedback: feedback.getState(effectiveProjectId, 'observation', String(observation.id)),
+                        }),
                     }))
                     .sort((a, b) => b.retention.displayScore - a.retention.displayScore);
                 const summary = summarizeRetentionProjections(rows.map((row) => row.retention));
@@ -580,26 +610,18 @@ async function handleApi(
                 const { existsSync } = await import('node:fs');
                 const { join } = await import('node:path');
 
-                let yml: any = {};
                 // Use the real project root from dashboard state, not process.cwd()
                 const configProjectRoot = effectiveProjectRoot;
-                try {
-                    const { loadYamlConfig } = await import('../config/yaml-loader.js');
-                    yml = configProjectRoot ? loadYamlConfig(configProjectRoot) : loadYamlConfig(null);
-                } catch { /* best effort */ }
-
-                // Load .env files so process.env reflects actual config (fixes #74, #62)
-                if (configProjectRoot) {
-                    try {
-                        const { loadDotenv } = await import('../config/dotenv-loader.js');
-                        loadDotenv(configProjectRoot);
-                    } catch { /* best effort */ }
-                }
+                // This is the same TOML-first chain used by status and runtime lanes.
+                // Do not fall back to user config if a bound project cannot resolve.
+                const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
 
                 // Check which config files exist
                 const files: Record<string, { exists: boolean; path: string; unavailable?: boolean }> = {
                     'project memorix.yml': { exists: false, path: '', unavailable: !configProjectRoot },
                     'user memorix.yml': { exists: false, path: '' },
+                    'project memorix.toml': { exists: false, path: '', unavailable: !configProjectRoot },
+                    'user config.toml': { exists: false, path: '' },
                     'project .env': { exists: false, path: '', unavailable: !configProjectRoot },
                     'user .env': { exists: false, path: '' },
                     'legacy config.json': { exists: false, path: '' },
@@ -609,6 +631,8 @@ async function handleApi(
                     const paths: Record<string, string | null> = {
                         'project memorix.yml': configProjectRoot ? join(configProjectRoot, 'memorix.yml') : null,
                         'user memorix.yml': join(home, '.memorix', 'memorix.yml'),
+                        'project memorix.toml': configProjectRoot ? join(configProjectRoot, 'memorix.toml') : null,
+                        'user config.toml': join(home, '.memorix', 'config.toml'),
                         'project .env': configProjectRoot ? join(configProjectRoot, '.env') : null,
                         'user .env': join(home, '.memorix', '.env'),
                         'legacy config.json': join(home, '.memorix', 'config.json'),
@@ -626,82 +650,83 @@ async function handleApi(
                 const values: Array<{ key: string; value: string; source: string; sensitive?: boolean }> = [];
 
                 // LLM
-                // Helper: determine source label (distinguishes .env file vs system env)
-                const getEnvSource = async (envKey: string, ymlSource?: string): Promise<string> => {
-                    if (process.env[envKey]) {
-                        // Check if this key was injected by dotenv-loader (from .env file)
-                        try {
-                            const { getLoadedEnvFiles } = await import('../config/dotenv-loader.js');
-                            const envFiles = getLoadedEnvFiles();
-                            if (envFiles.length > 0) return `.env (${envKey})`;
-                        } catch { /* ignore */ }
-                        return `env:${envKey}`;
-                    }
-                    return ymlSource ?? 'default';
-                };
+                const tomlSource = configProjectRoot && files['project memorix.toml'].exists
+                    ? 'memorix.toml'
+                    : files['user config.toml'].exists ? 'config.toml' : 'default';
+                const legacySource = files['project memorix.yml'].exists || files['user memorix.yml'].exists
+                    ? 'memorix.yml'
+                    : files['legacy config.json'].exists ? 'config.json' : 'default';
+                const configSource = resolved.sources.toml.length > 0 ? tomlSource
+                    : resolved.sources.legacy.length > 0 ? legacySource : 'default';
+                const source = (envKey: string): string => resolveDashboardKeySource({
+                    value: process.env[envKey] ?? '',
+                    envKeys: [envKey],
+                    configSource,
+                });
 
-                const llmProvider = process.env.MEMORIX_LLM_PROVIDER || yml.llm?.provider;
-                if (llmProvider) values.push({ key: 'llm.provider', value: llmProvider, source: await getEnvSource('MEMORIX_LLM_PROVIDER', yml.llm?.provider ? 'memorix.yml' : undefined) });
+                if (resolved.memory.llm.provider) values.push({ key: 'llm.provider', value: resolved.memory.llm.provider, source: source('MEMORIX_LLM_PROVIDER') });
 
-                const llmModel = process.env.MEMORIX_LLM_MODEL || yml.llm?.model;
-                if (llmModel) values.push({ key: 'llm.model', value: llmModel, source: await getEnvSource('MEMORIX_LLM_MODEL', yml.llm?.model ? 'memorix.yml' : undefined) });
+                if (resolved.memory.llm.model) values.push({ key: 'llm.model', value: resolved.memory.llm.model, source: source('MEMORIX_LLM_MODEL') });
 
-                const llmKey = process.env.MEMORIX_LLM_API_KEY || process.env.MEMORIX_API_KEY || yml.llm?.apiKey || process.env.OPENAI_API_KEY;
+                const llmKey = resolved.memory.llm.apiKey;
+                const memoryKeyEnv = [
+                    'MEMORIX_LLM_API_KEY',
+                    'MEMORIX_API_KEY',
+                    'OPENAI_API_KEY',
+                    'ANTHROPIC_API_KEY',
+                    ...(resolved.memory.llm.provider === 'openrouter' || resolved.memory.llm.baseUrl?.includes('openrouter.ai')
+                        ? ['OPENROUTER_API_KEY']
+                        : []),
+                ];
                 if (llmKey) {
-                    let src = 'unknown';
-                    if (process.env.MEMORIX_LLM_API_KEY) src = await getEnvSource('MEMORIX_LLM_API_KEY');
-                    else if (process.env.MEMORIX_API_KEY) src = await getEnvSource('MEMORIX_API_KEY');
-                    else if (yml.llm?.apiKey) src = 'memorix.yml (move to .env!)';
-                    else if (process.env.OPENAI_API_KEY) src = await getEnvSource('OPENAI_API_KEY');
+                    const src = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });
                     values.push({ key: 'llm.apiKey', value: '****' + llmKey.slice(-4), source: src, sensitive: true });
                 } else {
                     values.push({ key: 'llm.apiKey', value: 'not set', source: 'none' });
                 }
 
-                const agentProvider = process.env.MEMORIX_AGENT_PROVIDER || process.env.MEMORIX_AGENT_LLM_PROVIDER || yml.agent?.provider;
-                if (agentProvider) {
-                    let source: string;
-                    if (process.env.MEMORIX_AGENT_PROVIDER) source = await getEnvSource('MEMORIX_AGENT_PROVIDER');
-                    else if (process.env.MEMORIX_AGENT_LLM_PROVIDER) source = `${await getEnvSource('MEMORIX_AGENT_LLM_PROVIDER')} (legacy)`;
-                    else source = yml.agent?.provider ? 'memorix.yml' : 'default';
-                    values.push({ key: 'agent.provider', value: agentProvider, source });
+                if (resolved.agent.provider) {
+                    values.push({ key: 'agent.provider', value: resolved.agent.provider, source: source('MEMORIX_AGENT_PROVIDER') });
                 }
 
-                const agentModel = process.env.MEMORIX_AGENT_MODEL || process.env.MEMORIX_AGENT_LLM_MODEL || yml.agent?.model;
-                if (agentModel) {
-                    let source: string;
-                    if (process.env.MEMORIX_AGENT_MODEL) source = await getEnvSource('MEMORIX_AGENT_MODEL');
-                    else if (process.env.MEMORIX_AGENT_LLM_MODEL) source = `${await getEnvSource('MEMORIX_AGENT_LLM_MODEL')} (legacy)`;
-                    else source = yml.agent?.model ? 'memorix.yml' : 'default';
-                    values.push({ key: 'agent.model', value: agentModel, source });
+                if (resolved.agent.model) {
+                    values.push({ key: 'agent.model', value: resolved.agent.model, source: source('MEMORIX_AGENT_MODEL') });
                 }
 
-                const agentKey = process.env.MEMORIX_AGENT_API_KEY || process.env.MEMORIX_AGENT_LLM_API_KEY || yml.agent?.apiKey;
+                const agentKey = resolved.agent.apiKey;
                 if (agentKey) {
-                    let src = 'unknown';
-                    if (process.env.MEMORIX_AGENT_API_KEY) src = await getEnvSource('MEMORIX_AGENT_API_KEY');
-                    else if (process.env.MEMORIX_AGENT_LLM_API_KEY) src = `${await getEnvSource('MEMORIX_AGENT_LLM_API_KEY')} (legacy)`;
-                    else if (yml.agent?.apiKey) src = 'memorix.yml (move to .env!)';
+                    const src = resolveDashboardKeySource({
+                        value: agentKey,
+                        envKeys: ['MEMORIX_AGENT_API_KEY', 'MEMORIX_AGENT_LLM_API_KEY'],
+                        configSource,
+                    });
                     values.push({ key: 'agent.apiKey', value: '****' + agentKey.slice(-4), source: src, sensitive: true });
                 } else {
-                    values.push({ key: 'agent.apiKey', value: 'fallback to llm.apiKey', source: 'default' });
+                    values.push({
+                        key: 'agent.apiKey',
+                        value: 'fallback to llm.apiKey',
+                        source: llmKey
+                            ? resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource })
+                            : 'default',
+                    });
                 }
 
                 // Embedding
-                const embProvider = process.env.MEMORIX_EMBEDDING || yml.embedding?.provider || 'off';
-                values.push({ key: 'embedding.provider', value: embProvider, source: await getEnvSource('MEMORIX_EMBEDDING', yml.embedding?.provider ? 'memorix.yml' : undefined) });
+                values.push({ key: 'embedding.provider', value: resolved.embedding.provider || 'off', source: source('MEMORIX_EMBEDDING') });
+                if (resolved.embedding.model) values.push({ key: 'embedding.model', value: resolved.embedding.model, source: source('MEMORIX_EMBEDDING_MODEL') });
 
-                // Git
-                values.push({ key: 'git.autoHook', value: String(yml.git?.autoHook ?? false), source: yml.git?.autoHook !== undefined ? 'memorix.yml' : 'default' });
-                values.push({ key: 'git.skipMergeCommits', value: String(yml.git?.skipMergeCommits ?? true), source: yml.git?.skipMergeCommits !== undefined ? 'memorix.yml' : 'default' });
+                if (resolved.rerank.provider !== 'off') {
+                    values.push({ key: 'rerank.provider', value: resolved.rerank.provider, source: source('MEMORIX_RERANK_PROVIDER') });
+                    if (resolved.rerank.model) values.push({ key: 'rerank.model', value: resolved.rerank.model, source: source('MEMORIX_RERANK_MODEL') });
+                }
 
-                // Behavior
-                if (yml.behavior?.formationMode) values.push({ key: 'behavior.formationMode', value: yml.behavior.formationMode, source: 'memorix.yml' });
-                if (yml.behavior?.sessionInject) values.push({ key: 'behavior.sessionInject', value: yml.behavior.sessionInject, source: 'memorix.yml' });
+                // Git
+                values.push({ key: 'git.autoHook', value: String(resolved.git.autoHook ?? false), source: configSource });
+                values.push({ key: 'git.skipMergeCommits', value: String(resolved.git.skipMergeCommits ?? true), source: configSource });
 
                 // Server
-                values.push({ key: 'server.transport', value: yml.server?.transport || 'stdio', source: yml.server?.transport ? 'memorix.yml' : 'default' });
-                values.push({ key: 'server.dashboard', value: String(yml.server?.dashboard ?? true), source: yml.server?.dashboard !== undefined ? 'memorix.yml' : 'default' });
+                values.push({ key: 'server.transport', value: resolved.server.transport || 'stdio', source: configSource });
+                values.push({ key: 'server.dashboard', value: String(resolved.server.dashboard ?? true), source: configSource });
 
                 sendJson(res, { files, values });
                 break;

package/src/dashboard/static/index.html

@@ -92,6 +92,15 @@
         </svg>
         <span class="nav-label">Observations</span>
       </button>
+      <button class="nav-btn" data-page="evidence" title="Evidence" aria-label="Evidence">
+        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+          <polyline points="14 2 14 8 20 8"/>
+          <line x1="8" y1="13" x2="16" y2="13"/>
+          <line x1="8" y1="17" x2="14" y2="17"/>
+        </svg>
+        <span class="nav-label">Evidence</span>
+      </button>
     </div>
     <div class="sidebar-section-label" data-section="health">HEALTH</div>
     <div class="sidebar-nav">
@@ -175,6 +184,7 @@
     <div id="page-knowledge" class="page"></div>
     <div id="page-graph" class="page"></div>
     <div id="page-observations" class="page"></div>
+    <div id="page-evidence" class="page"></div>
     <div id="page-retention" class="page"></div>
     <div id="page-config" class="page"></div>
     <div id="page-identity" class="page"></div>

package/src/dashboard/static/style.css

@@ -64,6 +64,92 @@
   --transition-emphasized: 500ms cubic-bezier(0.2, 0, 0, 1);
 }
 
+/* Evidence Console: provenance is readable at a glance and stays bounded on
+   narrow screens; long paths and generated titles never widen the viewport. */
+.evidence-console {
+  display: grid;
+  gap: 12px;
+  min-width: 0;
+}
+
+.evidence-card {
+  border: 1px solid var(--border-color, rgba(148, 163, 184, .18));
+  border-radius: 8px;
+  background: var(--surface, rgba(15, 23, 42, .45));
+  padding: 16px;
+  min-width: 0;
+}
+
+.evidence-card-header {
+  display: flex;
+  gap: 12px;
+  align-items: flex-start;
+  justify-content: space-between;
+  min-width: 0;
+}
+
+.evidence-card-heading {
+  min-width: 0;
+}
+
+.evidence-card-heading h2 {
+  margin: 4px 0 0;
+  font-size: 16px;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+
+.evidence-card-kind {
+  color: var(--text-muted);
+  font-size: 11px;
+  text-transform: uppercase;
+}
+
+.evidence-card-state {
+  display: flex;
+  gap: 6px;
+  flex: 0 0 auto;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.evidence-state {
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  padding: 3px 7px;
+  font-size: 11px;
+  white-space: nowrap;
+}
+
+.evidence-current, .evidence-verified { color: #4ade80; }
+.evidence-stale, .evidence-conflicted { color: #fb923c; }
+.evidence-unverified { color: var(--text-muted); }
+
+.evidence-card-summary {
+  margin: 12px 0;
+  color: var(--text-secondary, var(--text-muted));
+  line-height: 1.55;
+  overflow-wrap: anywhere;
+}
+
+.evidence-card-meta {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 10px;
+  margin: 0;
+}
+
+.evidence-card-meta div { min-width: 0; }
+.evidence-card-meta dt { color: var(--text-muted); font-size: 11px; margin-bottom: 3px; }
+.evidence-card-meta dd { margin: 0; font-size: 12px; overflow-wrap: anywhere; }
+.evidence-card-warning { margin-top: 10px; color: #fb923c; font-size: 12px; overflow-wrap: anywhere; }
+
+@media (max-width: 600px) {
+  .evidence-card-header { display: block; }
+  .evidence-card-state { justify-content: flex-start; margin-top: 10px; }
+  .evidence-card-meta { grid-template-columns: 1fr; }
+}
+
 /* Light Theme - MD3 */
 [data-theme="light"] {
   --bg-base: #FFFBFE;

package/src/hooks/installers/index.ts

@@ -1259,7 +1259,7 @@ function getAgentRulesContent(agent?: AgentName, scope: 'project' | 'global' = '
     '',
     `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. 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>" --brief-json\x60. For a new task, use \x60memorix context "<task>" --brief-json\x60 instead. The absence of \x60.memorix\x60 or visible memory files never proves project memory is empty. Use \x60--json\x60 only when a diagnostic needs the detailed legacy payload. 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.',
+    '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>" --fallback --brief-json\x60. For a new task, use \x60memorix context "<task>" --fallback --brief-json\x60 instead. The absence of \x60.memorix\x60 or visible memory files never proves project memory is empty. Use \x60--json\x60 only when a diagnostic needs the detailed legacy payload. 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.',
     '',
     '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.',

package/src/hooks/official-skills.ts

@@ -31,8 +31,8 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '| Situation | Prefer | CLI fallback |',
       '|---|---|---|',
-      '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --brief-json` |',
-      '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --brief-json` |',
+      '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --fallback --brief-json` |',
+      '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --fallback --brief-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>"` |',
@@ -45,7 +45,7 @@ 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.',
-      '- 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>" --brief-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>" --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+      '- 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>" --fallback --brief-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>" --fallback --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. 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.',

package/src/hooks/rules/memorix-agent-rules.md

@@ -7,7 +7,7 @@ You have access to Memorix memory tools. Follow these rules to maintain persiste
 At the beginning of non-trivial coding work, use Memorix Memory Autopilot before local progress notes or broad file exploration. A session bind is not required for every conversation.
 
 1. Default first step for non-trivial coding work: call `memorix_project_context` 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 code or docs to inspect.
-2. If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` 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: use `memorix resume "<task>" --brief-json`. For a new task, use `memorix context "<task>" --brief-json` instead. The absence of `.memorix` 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 `--json` only when a diagnostic needs the detailed legacy payload.
+2. If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` 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: use `memorix resume "<task>" --fallback --brief-json`. For a new task, use `memorix context "<task>" --fallback --brief-json` instead. The absence of `.memorix` 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 `--json` only when a diagnostic needs the detailed legacy payload.
 3. After a successful `memorix_project_context` result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use `memorix_context_pack`, `memorix_search`, or `memorix_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.
 4. Use `memorix_context_pack` when you need structured refs and freshness for code-bound memories.

package/src/memory/feedback-model.ts

@@ -0,0 +1,4 @@
+/** Pure feedback math shared by retrieval/retention without opening SQLite. */
+export function feedbackWeightMultiplier(weight: number): number {
+  return Math.max(0.35, Math.min(1.4, 0.35 + Math.max(0, Math.min(2, weight)) * 0.525));
+}