memorix 1.6.2 → 1.7.0

package/src/dashboard/static/style.css

@@ -2148,6 +2148,316 @@ body {
   color: var(--text-primary);
 }
 
+/* Maintenance workbench */
+.maintenance-strip {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 12px 0;
+  margin-bottom: 14px;
+  border-top: 1px solid var(--border-subtle);
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.maintenance-strip-heading {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.maintenance-strip-heading small {
+  font-size: 11px;
+  font-weight: 400;
+  color: var(--text-muted);
+}
+
+.maintenance-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.maintenance-actions button,
+.maintenance-primary,
+.maintenance-secondary {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 7px;
+  min-height: 36px;
+  padding: 8px 12px;
+  border: 1px solid var(--border-medium);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-secondary);
+  font: 500 12px var(--font-sans);
+  cursor: pointer;
+  transition: background var(--transition-fast), border-color var(--transition-fast), color var(--transition-fast);
+}
+
+.maintenance-actions button:hover,
+.maintenance-secondary:hover {
+  background: var(--bg-card-hover);
+  border-color: var(--text-muted);
+  color: var(--text-primary);
+}
+
+.maintenance-dialog {
+  width: min(680px, calc(100vw - 32px));
+  max-height: min(760px, calc(100dvh - 32px));
+  padding: 0;
+  border: 1px solid var(--border-medium);
+  border-radius: var(--radius-md);
+  background: var(--bg-surface);
+  color: var(--text-primary);
+  box-shadow: var(--elevation-3);
+  overflow: hidden;
+}
+
+.maintenance-dialog::backdrop {
+  background: rgba(5, 5, 12, 0.72);
+  backdrop-filter: blur(3px);
+}
+
+.maintenance-dialog-shell {
+  display: grid;
+  grid-template-rows: auto minmax(0, 1fr) auto;
+  max-height: min(760px, calc(100dvh - 32px));
+}
+
+.maintenance-dialog-header,
+.maintenance-dialog-footer {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 16px 18px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.maintenance-dialog-footer {
+  justify-content: flex-end;
+  border-top: 1px solid var(--border-subtle);
+  border-bottom: 0;
+}
+
+.maintenance-dialog-kicker {
+  margin-bottom: 3px;
+  font: 500 10px var(--font-mono);
+  color: var(--text-muted);
+  text-transform: uppercase;
+}
+
+.maintenance-dialog-header h2 {
+  font-size: 17px;
+  line-height: 1.3;
+}
+
+.maintenance-dialog-close {
+  width: 34px;
+  height: 34px;
+  flex: 0 0 34px;
+}
+
+.maintenance-dialog-body {
+  min-height: 180px;
+  overflow: auto;
+  padding: 18px;
+}
+
+.maintenance-summary {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+  border-top: 1px solid var(--border-subtle);
+  border-bottom: 1px solid var(--border-subtle);
+  margin-bottom: 16px;
+}
+
+.maintenance-metric {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  min-width: 0;
+  padding: 12px;
+  border-right: 1px solid var(--border-subtle);
+}
+
+.maintenance-metric:last-child {
+  border-right: 0;
+}
+
+.maintenance-metric span {
+  font-size: 10px;
+  color: var(--text-muted);
+}
+
+.maintenance-metric strong {
+  font: 600 19px var(--font-mono);
+  color: var(--text-primary);
+}
+
+.maintenance-records,
+.maintenance-group {
+  display: flex;
+  flex-direction: column;
+}
+
+.maintenance-group {
+  margin-bottom: 12px;
+  border-top: 1px solid var(--border-subtle);
+}
+
+.maintenance-group-title {
+  padding: 10px 8px 6px;
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+
+.maintenance-record {
+  display: grid;
+  grid-template-columns: 52px minmax(0, 1fr) minmax(80px, auto);
+  align-items: center;
+  gap: 10px;
+  min-height: 42px;
+  padding: 8px;
+  border-bottom: 1px solid var(--border-subtle);
+  font-size: 12px;
+}
+
+.maintenance-record-id,
+.maintenance-record-meta {
+  font-family: var(--font-mono);
+  color: var(--text-muted);
+}
+
+.maintenance-record-title,
+.maintenance-record-meta {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.maintenance-record-meta {
+  text-align: right;
+  font-size: 10px;
+}
+
+.maintenance-toggle {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  margin-bottom: 14px;
+  font-size: 12px;
+  color: var(--text-secondary);
+  cursor: pointer;
+}
+
+.maintenance-toggle input {
+  width: 16px;
+  height: 16px;
+  accent-color: var(--accent-purple);
+}
+
+.maintenance-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  min-height: 130px;
+  color: var(--text-muted);
+  text-align: center;
+}
+
+.maintenance-primary {
+  border-color: var(--accent-purple);
+  background: var(--accent-purple);
+  color: var(--bg-base);
+}
+
+.maintenance-primary:hover:not(:disabled) {
+  filter: brightness(1.08);
+}
+
+.maintenance-primary:disabled,
+.export-btn:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
+}
+
+.dashboard-toast {
+  position: fixed;
+  right: 20px;
+  bottom: 20px;
+  z-index: 1200;
+  max-width: min(420px, calc(100vw - 40px));
+  padding: 11px 14px;
+  border: 1px solid var(--accent-green);
+  border-radius: var(--radius-sm);
+  background: var(--bg-card);
+  color: var(--text-primary);
+  box-shadow: var(--elevation-2);
+  font-size: 12px;
+  opacity: 0;
+  transform: translateY(10px);
+  pointer-events: none;
+  transition: opacity var(--transition-fast), transform var(--transition-fast);
+}
+
+.dashboard-toast[data-tone="error"] {
+  border-color: var(--accent-red);
+}
+
+.dashboard-toast.visible {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+.page-header-actions {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+@media (max-width: 720px) {
+  .maintenance-strip,
+  .page-header-actions {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .maintenance-actions {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
+  .maintenance-actions button {
+    min-width: 0;
+    padding-inline: 8px;
+  }
+
+  .maintenance-record {
+    grid-template-columns: 44px minmax(0, 1fr);
+  }
+
+  .maintenance-record-meta {
+    grid-column: 2;
+    text-align: left;
+  }
+
+  .maintenance-dialog-body {
+    padding: 14px;
+  }
+}
+
 /* Low quality indicator */
 .obs-card.low-quality {
   border-left: 3px solid var(--accent-amber);

package/src/memory/cleanup.ts

@@ -0,0 +1,143 @@
+import type { Observation } from '../types.js';
+import type { ObservationStore } from '../store/obs-store.js';
+
+const LOW_QUALITY_PATTERNS = [
+  /^Session activity/i,
+  /^Updated \S+\.\w+$/i,
+  /^Created \S+\.\w+$/i,
+  /^Deleted \S+\.\w+$/i,
+  /^Modified \S+\.\w+$/i,
+  /^Ran command:/i,
+  /^Read file:/i,
+];
+
+const EXPLICIT_NOISE_TITLE_PATTERNS = [
+  /^\s*\[(?:test|demo|benchmark|sandbox|playground|测试|演示)\]/i,
+  /^\s*(?:Used\s+(?:mcp__\S+|apply_patch)|Ran:)\s*/i,
+];
+
+const EXPLICIT_NOISE_MARKERS = new Set([
+  'test-fixture',
+  'demo-fixture',
+  'benchmark-fixture',
+  'sandbox-fixture',
+  'cleanup-noise',
+]);
+
+export interface CleanupNoiseHit {
+  observation: Observation;
+  reason: 'system-self' | 'demo/test/noise';
+}
+
+export interface CleanupDuplicateGroup {
+  canonical: Observation;
+  duplicates: Observation[];
+}
+
+export interface CleanupAnalysis {
+  totalActive: number;
+  highQuality: number;
+  lowQuality: Observation[];
+  duplicateGroups: CleanupDuplicateGroup[];
+  duplicates: Observation[];
+  noise: CleanupNoiseHit[];
+  toRemove: Observation[];
+  toArchive: Observation[];
+}
+
+export function isLowQualityObservation(title: string): boolean {
+  return LOW_QUALITY_PATTERNS.some((pattern) => pattern.test(title.trim()));
+}
+
+export function classifyNoiseObservation(
+  observation: Pick<Observation, 'title' | 'narrative' | 'entityName' | 'facts' | 'concepts'>,
+): { isNoise: boolean; reason?: CleanupNoiseHit['reason'] } {
+  const title = observation.title?.trim() ?? '';
+  const entityName = observation.entityName?.trim().toLowerCase() ?? '';
+  const concepts = (observation.concepts ?? []).map((concept) => concept.trim().toLowerCase());
+
+  if (
+    entityName === 'memorix.demo'
+    || entityName.startsWith('for_memmcp_test')
+    || concepts.some((concept) => EXPLICIT_NOISE_MARKERS.has(concept))
+  ) {
+    return { isNoise: true, reason: 'system-self' };
+  }
+  if (EXPLICIT_NOISE_TITLE_PATTERNS.some((pattern) => pattern.test(title))) {
+    return { isNoise: true, reason: 'demo/test/noise' };
+  }
+  return { isNoise: false };
+}
+
+export function analyzeCleanupObservations(
+  observations: readonly Observation[],
+  options: { includeNoise?: boolean } = {},
+): CleanupAnalysis {
+  const active = observations.filter((observation) => (observation.status ?? 'active') === 'active');
+  const lowQuality = active.filter((observation) => isLowQualityObservation(observation.title ?? ''));
+  const lowQualityIds = new Set(lowQuality.map((observation) => observation.id));
+  const highQuality = active.filter((observation) => !lowQualityIds.has(observation.id));
+
+  const groups = new Map<string, CleanupDuplicateGroup>();
+  for (const observation of highQuality) {
+    const key = `${observation.type}|${observation.title}|${observation.entityName}`;
+    const existing = groups.get(key);
+    if (existing) existing.duplicates.push(observation);
+    else groups.set(key, { canonical: observation, duplicates: [] });
+  }
+  const duplicateGroups = [...groups.values()].filter((group) => group.duplicates.length > 0);
+  const duplicates = duplicateGroups.flatMap((group) => group.duplicates);
+  const excludedIds = new Set([...lowQuality, ...duplicates].map((observation) => observation.id));
+
+  const noise: CleanupNoiseHit[] = [];
+  if (options.includeNoise) {
+    for (const observation of active) {
+      if (excludedIds.has(observation.id)) continue;
+      const classification = classifyNoiseObservation(observation);
+      if (classification.isNoise && classification.reason) {
+        noise.push({ observation, reason: classification.reason });
+      }
+    }
+  }
+
+  const toRemove = [...lowQuality, ...duplicates];
+  const toArchive = noise.map((hit) => hit.observation);
+  return {
+    totalActive: active.length,
+    highQuality: highQuality.length - duplicates.length - toArchive.length,
+    lowQuality,
+    duplicateGroups,
+    duplicates,
+    noise,
+    toRemove,
+    toArchive,
+  };
+}
+
+function requireObservationIds(observations: readonly Observation[], action: string): number[] {
+  const ids = observations.map((observation) => observation.id);
+  if (ids.some((id) => typeof id !== 'number')) {
+    throw new Error(`Cannot ${action}: an observation has no persisted ID.`);
+  }
+  return ids as number[];
+}
+
+export async function applyCleanupMutations(
+  store: ObservationStore,
+  toArchive: readonly Observation[],
+  toRemove: readonly Observation[],
+): Promise<{ archived: number; removed: number }> {
+  const archiveIds = requireObservationIds(toArchive, 'archive');
+  const removeIds = requireObservationIds(toRemove, 'delete');
+  const removals = new Set(removeIds);
+  if (archiveIds.some((id) => removals.has(id))) {
+    throw new Error('Cleanup cannot archive and delete the same observation.');
+  }
+
+  await store.atomic(async (tx) => {
+    await Promise.all(archiveIds.map((id) => tx.setStatus(id, 'archived', 'active')));
+    await Promise.all(removeIds.map((id) => tx.remove(id)));
+  });
+
+  return { archived: archiveIds.length, removed: removeIds.length };
+}

package/src/memory/deduplication.ts

@@ -0,0 +1,178 @@
+import type { CompactDecision } from '../llm/memory-manager.js';
+import { deduplicateMemory } from '../llm/memory-manager.js';
+import type { ObservationStore } from '../store/obs-store.js';
+import type { Observation, ObservationReader } from '../types.js';
+import { canManageObservation } from './visibility.js';
+
+export interface DeduplicationAction {
+  resolveId: number;
+  keepId: number;
+  entityName: string;
+  resolveTitle: string;
+  keepTitle: string;
+  reason: string;
+  decision: 'UPDATE' | 'DELETE' | 'NONE';
+  usedLLM: boolean;
+}
+
+export interface DeduplicationPlan {
+  scanned: number;
+  entities: number;
+  comparisons: number;
+  failedComparisons: number;
+  actions: DeduplicationAction[];
+  resolveIds: number[];
+}
+
+type DeduplicationDecision = (
+  newer: { title: string; narrative: string; facts: string[] },
+  existing: Array<{ id: number; title: string; narrative: string; facts: string }>,
+) => Promise<CompactDecision | null>;
+
+function chronological(left: Observation, right: Observation): number {
+  const byTime = new Date(left.createdAt).getTime() - new Date(right.createdAt).getTime();
+  return byTime || left.id - right.id;
+}
+
+function actionFromDecision(
+  older: Observation,
+  newer: Observation,
+  decision: CompactDecision,
+): DeduplicationAction | null {
+  let resolveId: number;
+  let keepId: number;
+
+  if (decision.action === 'NONE') {
+    resolveId = newer.id;
+    keepId = older.id;
+  } else if (decision.action === 'UPDATE') {
+    resolveId = decision.targetId ?? older.id;
+    keepId = resolveId === newer.id ? older.id : newer.id;
+  } else if (decision.action === 'DELETE') {
+    resolveId = decision.targetId ?? older.id;
+    keepId = resolveId === newer.id ? older.id : newer.id;
+  } else {
+    return null;
+  }
+
+  const records = new Map([[older.id, older], [newer.id, newer]]);
+  const resolved = records.get(resolveId);
+  const kept = records.get(keepId);
+  if (!resolved || !kept || resolved.id === kept.id) return null;
+
+  return {
+    resolveId,
+    keepId,
+    entityName: newer.entityName,
+    resolveTitle: resolved.title,
+    keepTitle: kept.title,
+    reason: decision.reason,
+    decision: decision.action,
+    usedLLM: decision.usedLLM,
+  };
+}
+
+/**
+ * Build one deterministic, reviewable deduplication plan. Callers own project,
+ * visibility, and optional search filtering before passing observations in.
+ */
+export async function planMemoryDeduplication(
+  observations: readonly Observation[],
+  options: { limit?: number; decide?: DeduplicationDecision } = {},
+): Promise<DeduplicationPlan> {
+  const limit = Math.min(100, Math.max(2, Math.floor(options.limit ?? 20)));
+  const candidates = observations
+    .filter((observation) => (observation.status ?? 'active') === 'active')
+    .sort(chronological)
+    .slice(-limit);
+  const byEntity = new Map<string, Observation[]>();
+  for (const observation of candidates) {
+    const group = byEntity.get(observation.entityName) ?? [];
+    group.push(observation);
+    byEntity.set(observation.entityName, group);
+  }
+
+  const decide = options.decide ?? deduplicateMemory;
+  const actions = new Map<number, DeduplicationAction>();
+  let comparisons = 0;
+  let failedComparisons = 0;
+
+  for (const group of byEntity.values()) {
+    if (group.length < 2) continue;
+    group.sort(chronological);
+    for (let index = 0; index < group.length; index += 1) {
+      for (let compareIndex = index + 1; compareIndex < group.length; compareIndex += 1) {
+        const older = group[index];
+        const newer = group[compareIndex];
+        comparisons += 1;
+        let decision: CompactDecision | null;
+        try {
+          decision = await decide(
+            { title: newer.title, narrative: newer.narrative, facts: newer.facts },
+            [{ id: older.id, title: older.title, narrative: older.narrative, facts: older.facts.join('\n') }],
+          );
+        } catch {
+          failedComparisons += 1;
+          continue;
+        }
+        if (!decision) continue;
+        const action = actionFromDecision(older, newer, decision);
+        if (action && !actions.has(action.resolveId)) actions.set(action.resolveId, action);
+      }
+    }
+  }
+
+  const planned = [...actions.values()];
+  for (const [entityName, group] of byEntity) {
+    const resolvedIds = new Set(
+      planned.filter((action) => action.entityName === entityName).map((action) => action.resolveId),
+    );
+    if (group.length > 0 && group.every((observation) => resolvedIds.has(observation.id))) {
+      const survivor = group[group.length - 1];
+      const unsafeIndex = planned.findIndex((action) => action.resolveId === survivor.id);
+      if (unsafeIndex >= 0) planned.splice(unsafeIndex, 1);
+    }
+  }
+  return {
+    scanned: candidates.length,
+    entities: byEntity.size,
+    comparisons,
+    failedComparisons,
+    actions: planned,
+    resolveIds: planned.map((action) => action.resolveId),
+  };
+}
+
+export async function applyDeduplicationPlan(
+  store: ObservationStore,
+  projectId: string,
+  resolveIds: readonly number[],
+  reader: ObservationReader = { projectId },
+): Promise<{ resolved: number[]; skipped: number[] }> {
+  const uniqueIds = [...new Set(resolveIds)];
+  const manageable: number[] = [];
+  const skipped: number[] = [];
+
+  for (const id of uniqueIds) {
+    const observation = await store.getById(id);
+    if (
+      observation
+      && observation.projectId === projectId
+      && (observation.status ?? 'active') === 'active'
+      && canManageObservation(observation, reader)
+    ) {
+      manageable.push(id);
+    } else {
+      skipped.push(id);
+    }
+  }
+
+  const resolved = skipped.length > 0 || manageable.length === 0
+    ? []
+    : await store.atomic(async (tx) => {
+      const updates = await Promise.all(manageable.map((id) => tx.setStatus(id, 'resolved', 'active')));
+      return manageable.filter((_, index) => updates[index]);
+    });
+
+  return { resolved, skipped };
+}

package/src/memory/session.ts

@@ -140,10 +140,20 @@ async function loadAliasActiveSessions(projectIds: Set<string>): Promise<Session
   return groups.flat();
 }
 
-async function loadAliasActiveObservations(projectIds: Set<string>): Promise<Observation[]> {
+const SESSION_RESUME_OBSERVATION_LIMIT = 64;
+const SESSION_CONTEXT_OBSERVATION_LIMIT = 128;
+
+async function loadAliasActiveObservations(
+  projectIds: Set<string>,
+  limit: number = SESSION_RESUME_OBSERVATION_LIMIT,
+): Promise<Observation[]> {
   const store = getObservationStore();
   const groups = await Promise.all(
-    [...projectIds].map((projectId) => store.loadByProject(projectId, { status: 'active' })),
+    [...projectIds].map((projectId) => store.loadByProject(projectId, {
+      status: 'active',
+      limit,
+      newestFirst: true,
+    })),
   );
   return groups.flat();
 }
@@ -522,7 +532,7 @@ export async function getSessionContext(
   const aliasSet = await resolveProjectIds(projectId);
   const [sessions, allObs] = await Promise.all([
     loadAliasSessions(aliasSet),
-    loadAliasActiveObservations(aliasSet),
+    loadAliasActiveObservations(aliasSet, SESSION_CONTEXT_OBSERVATION_LIMIT),
   ]);
   const readableObs = readableAliasObservations(allObs, aliasSet, reader);
   /** Check if a session summary contains noise/system-self content */