memorix 1.4.4 → 1.4.6

package/src/runtime/lifecycle.ts

@@ -83,6 +83,25 @@ export function enqueueObservationQualification(input: {
   });
 }
 
+/**
+ * Long-term memory maintains itself on a daily rule leg: stale active records
+ * archive themselves and newer records supersede same-title older ones. No
+ * LLM required; enqueueing is a durable no-op when nothing is due.
+ */
+export function enqueueLongTermMaintenance(input: {
+  dataDir: string;
+  projectId: string;
+  source: string;
+  queue?: MaintenanceQueue;
+}): void {
+  queueFor(input).enqueue({
+    projectId: input.projectId,
+    kind: 'long-term-maintenance',
+    dedupeKey: 'long-term-maintenance',
+    payload: { source: input.source },
+  });
+}
+
 /**
  * The follow-up jobs operate on the same workspace the Workset reads: a
  * versioned workspace when present, otherwise the local workspace.

package/src/runtime/maintenance-jobs.ts

@@ -16,6 +16,7 @@ export const MAINTENANCE_JOB_KINDS = [
   'knowledge-compile',
   'knowledge-lint',
   'workflow-index',
+  'long-term-maintenance',
 ] as const;
 
 export type MaintenanceJobKind = typeof MAINTENANCE_JOB_KINDS[number];

package/src/runtime/project-maintenance.ts

@@ -263,6 +263,14 @@ export function createProjectMaintenanceHandler(
       return { action: 'complete' };
     }
 
+    if (job.kind === 'long-term-maintenance') {
+      const { maintainLongTermMemories } = await import('../memory/long-term.js');
+      await maintainLongTermMemories({ dataDir: projectDir, projectId });
+      // Decay and supersede thresholds are measured in days: one daily pass is
+      // plenty. Rescheduling the same row keeps a quiet, durable heartbeat.
+      return { action: 'reschedule', delayMs: 24 * 60 * 60 * 1000, resetAttempts: true };
+    }
+
     if (job.kind === 'consolidation') {
       const limit = consolidationBatchSize(job.payload);
       const result = await runAutomaticConsolidation(projectId, projectDir, {

package/src/search/surfaced-registry.ts

@@ -0,0 +1,62 @@
+/**
+ * Surfaced-entry registry — session-level "already shown this session" bookkeeping.
+ *
+ * The retrieval layer can demote entries whose ids are marked as surfaced, so
+ * a coding session does not get the same memory rows re-shown for every
+ * related question. This registry is the state that remembers which ids have
+ * been shown, keyed by session scope.
+ *
+ * Design boundaries:
+ * - In-memory and bounded: at most MAX_KEYS scopes, at most MAX_IDS ids per
+ *   scope, oldest evicted first. Restarting the server resets it, which is
+ *   correct — "surfaced" only means "shown in this live session".
+ * - Best-effort: losing an entry only costs one redundant row, never data.
+ * - Scope keys are caller-owned strings (e.g. "session:<id>" or
+ *   "project:<id>"); the registry does not interpret them.
+ */
+
+const MAX_KEYS = 64;
+const MAX_IDS = 200;
+
+const registry = new Map<string, number[]>();
+
+function touch(key: string): number[] {
+  const ids = registry.get(key);
+  if (!ids) return [];
+  // Re-insert so Map iteration order approximates LRU for eviction.
+  registry.delete(key);
+  registry.set(key, ids);
+  return ids;
+}
+
+/** Ids already surfaced for this scope, oldest first. Never mutates state. */
+export function getSurfacedIds(key: string): number[] {
+  return [...touch(key)];
+}
+
+/** Mark ids as surfaced for this scope. New ids append; old ids overflow out. */
+export function recordSurfacedIds(key: string, ids: number[]): void {
+  if (ids.length === 0) return;
+
+  let list = registry.get(key) ?? [];
+  const known = new Set(list);
+  for (const id of ids) {
+    if (known.has(id)) continue;
+    known.add(id);
+    list.push(id);
+  }
+  if (list.length > MAX_IDS) {
+    list = list.slice(list.length - MAX_IDS);
+  }
+  registry.set(key, list);
+
+  if (registry.size > MAX_KEYS) {
+    const oldestKey = registry.keys().next().value;
+    if (oldestKey !== undefined && oldestKey !== key) registry.delete(oldestKey);
+  }
+}
+
+/** Test/teardown helper — resets all in-memory state. */
+export function clearSurfacedRegistry(): void {
+  registry.clear();
+}

package/src/server.ts

@@ -52,6 +52,7 @@ import type { FormationConfig, SearchHit, FormedMemory, FormationStage, Formatio
 import { parseFormationTimeoutMs } from './server/formation-timeout.js';
 import { withTimeout } from './timeout.js';
 import { sanitizeCredentials } from './memory/secret-filter.js';
+import { getSurfacedIds, recordSurfacedIds } from './search/surfaced-registry.js';
 import {
   createProjectBindingController,
   type ProjectBindingController,
@@ -508,6 +509,12 @@ export async function createMemorixServer(
         kind: 'consolidation',
         dedupeKey: 'startup-consolidation',
       });
+      lifecycle.enqueueLongTermMaintenance({
+        dataDir: projectDir,
+        projectId: project.id,
+        source: 'startup',
+        queue,
+      });
     }
 
     // This check is only a small SQLite metadata query. The actual directory
@@ -1152,7 +1159,7 @@ export async function createMemorixServer(
       let longTermNote = '';
       if (longTerm) {
         try {
-          const { promoteObservationToLongTermMemory } = await import('./memory/long-term.js');
+          const { promoteObservationToLongTermMemory, maybeAutoQualifyLongTermMemory } = await import('./memory/long-term.js');
           const promoted = await promoteObservationToLongTermMemory({
             dataDir: projectDir,
             observation: obs,
@@ -1166,7 +1173,28 @@ export async function createMemorixServer(
               ...(reader.isTeamMember ? { isTeamMember: true } : {}),
             },
           });
-          longTermNote = `\nLong-term candidate: ${promoted.memory.id} (${promoted.memory.kind}/${promoted.memory.scope}). Review it with the CLI before it is delivered automatically.`;
+          // An explicit store call carries its own source evidence: qualify
+          // on the spot instead of waiting for a manual CLI review.
+          const autoQualified = await maybeAutoQualifyLongTermMemory({
+            dataDir: projectDir,
+            id: promoted.memory.id,
+            sourceDetail: 'explicit',
+          });
+          if (autoQualified) {
+            // A fresh explicit record retires stale same-title records on the
+            // durable rule leg instead of waiting for the next session start.
+            try {
+              const { enqueueLongTermMaintenance } = await import('./runtime/lifecycle.js');
+              enqueueLongTermMaintenance({
+                dataDir: projectDir,
+                projectId: project.id,
+                source: 'long-term:' + promoted.memory.id,
+              });
+            } catch { /* maintenance is optional; the record already qualified */ }
+          }
+          longTermNote = autoQualified
+            ? `\nLong-term memory: ${promoted.memory.id} (${promoted.memory.kind}/${promoted.memory.scope}, auto-qualified) and now enters briefs as durable context. Audit with \`memorix memory long-term list\`.`
+            : `\nLong-term candidate: ${promoted.memory.id} (${promoted.memory.kind}/${promoted.memory.scope}). Review it with the CLI before it is delivered automatically.`;
         } catch (longTermError) {
           longTermNote = `\n[WARN] Observation stored, but long-term candidate was not created: ${longTermError instanceof Error ? longTermError.message : 'unknown error'}`;
         }
@@ -1394,6 +1422,17 @@ export async function createMemorixServer(
         const boundary = requireExplicitAutopilotExpansion('memorix_search', purpose);
         if (boundary) return boundary;
       }
+
+      // Session dedup scope: prefer the active session id, fall back to the
+      // bound project. Best-effort bookkeeping — losing it only costs one
+      // redundant result row, never data.
+      let surfacedKey = `project:${project.id}`;
+      try {
+        const { getActiveSession } = await import('./memory/session.js');
+        const active = await getActiveSession(projectDir, project.id);
+        if (active) surfacedKey = `session:${active.id}`;
+      } catch { /* fall back to the project key */ }
+
       return withFreshIndex(async () => {
 
       const safeLimit = limit != null ? coerceNumber(limit, 20) : undefined;
@@ -1415,6 +1454,7 @@ export async function createMemorixServer(
         source: source as 'agent' | 'git' | 'manual' | undefined,
         quality: quality as 'fast' | 'balanced' | 'thorough',
         reader: getObservationReader(scope === 'global' ? 'global' : 'project'),
+        surfacedIds: getSurfacedIds(surfacedKey),
       });
 
       let result;
@@ -1436,6 +1476,10 @@ export async function createMemorixServer(
         throw error;
       }
 
+      // These rows were just shown to the model — remember them so later
+      // searches in the same session demote instead of re-showing.
+      recordSurfacedIds(surfacedKey, result.entries.map(entry => entry.id));
+
       const activeBoundary = getActiveAutopilotRetrievalBoundary();
       if (
         scope !== 'global'
@@ -4998,6 +5042,12 @@ export async function createMemorixServer(
     return undefined;
   }
 
+  // The advertised schema matches what the operator actually enabled: a
+  // closed gate means the action does not exist for the agent, not that it
+  // exists and throws. The handler keeps its own runtime checks as well.
+  const mediaGenerationEnabled = process.env.MEMORIX_MCP_MEDIA_GENERATION === '1';
+  const mediaTranscriptionEnabled = process.env.MEMORIX_MCP_MEDIA_TRANSCRIPTION === '1';
+  const mediaGenerationOrTranscription = mediaGenerationEnabled || mediaTranscriptionEnabled;
   server.registerTool(
     'memorix_media',
     {
@@ -5008,7 +5058,11 @@ export async function createMemorixServer(
         'Use the CLI for destructive removal, quota cleanup, and direct generation. ' +
         'MCP generation is disabled by default and requires MEMORIX_MCP_MEDIA_GENERATION=1 after the operator reviews provider billing.',
       inputSchema: {
-        action: z.enum(['import', 'attach', 'list', 'show', 'derive-pdf', 'derive-audio', 'generate-image', 'generate-video', 'status', 'cancel']),
+        action: z.enum([
+          'import', 'attach', 'list', 'show', 'derive-pdf', 'status', 'cancel',
+          ...(mediaTranscriptionEnabled ? ['derive-audio'] : []),
+          ...(mediaGenerationEnabled ? ['generate-image', 'generate-video'] : []),
+        ] as [string, ...string[]]),
         path: z.string().optional().describe('Explicit local image/audio/video/PDF path for import.'),
         assetId: z.string().optional().describe('Controlled MediaAsset ID for attach/show.'),
         jobId: z.string().optional().describe('Durable media job ID for status.'),
@@ -5016,20 +5070,26 @@ export async function createMemorixServer(
         limit: z.number().int().min(1).max(100).optional().describe('Maximum assets to list.'),
         title: z.string().optional().describe('Observation title when attaching generated/imported output.'),
         narrative: z.string().optional().describe('Short retrieval text when attaching an asset.'),
-        prompt: z.string().optional().describe('Explicit MiniMax generation prompt.'),
-        image: z.string().optional().describe('Base64-encoded reference image for image-to-image generation.'),
-        model: z.string().max(160).optional().describe('Provider model for the selected media action.'),
-        provider: z.enum(['openai', 'groq']).optional().describe('Explicit audio transcription provider.'),
-        language: z.string().max(32).optional().describe('Optional ISO-639-1 hint for audio transcription.'),
-        region: z.enum(['global', 'cn']).optional().describe('MiniMax deployment region.'),
-        n: z.number().int().min(1).max(4).optional().describe('Image output count.'),
-        ratio: z.enum(['adaptive', '1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9']).optional().describe('Image or video aspect ratio.'),
-        width: z.number().int().min(1).max(8192).optional().describe('Requested image width.'),
-        height: z.number().int().min(1).max(8192).optional().describe('Requested image height.'),
-        duration: z.union([z.literal(5), z.literal(10)]).optional().describe('MiniMax video duration in seconds.'),
         maxPages: z.number().int().min(1).max(100).optional().describe('Bounded PDF extraction page limit.'),
         maxChars: z.number().int().min(1).max(60_000).optional().describe('Bounded PDF extraction character limit.'),
         attach: z.boolean().optional().describe('Attach generated/imported output to normal project memory explicitly.'),
+        ...(mediaGenerationOrTranscription ? {
+          model: z.string().max(160).optional().describe('Provider model for the selected media action.'),
+          prompt: z.string().optional().describe('Explicit prompt for generation or transcription.'),
+        } : {}),
+        ...(mediaTranscriptionEnabled ? {
+          provider: z.enum(['openai', 'groq']).optional().describe('Explicit audio transcription provider.'),
+          language: z.string().max(32).optional().describe('Optional ISO-639-1 hint for audio transcription.'),
+        } : {}),
+        ...(mediaGenerationEnabled ? {
+          image: z.string().optional().describe('Base64-encoded reference image for image-to-image generation.'),
+          region: z.enum(['global', 'cn']).optional().describe('MiniMax deployment region.'),
+          n: z.number().int().min(1).max(4).optional().describe('Image output count.'),
+          ratio: z.enum(['adaptive', '1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9']).optional().describe('Image or video aspect ratio.'),
+          width: z.number().int().min(1).max(8192).optional().describe('Requested image width.'),
+          height: z.number().int().min(1).max(8192).optional().describe('Requested image height.'),
+          duration: z.union([z.literal(5), z.literal(10)]).optional().describe('MiniMax video duration in seconds.'),
+        } : {}),
       },
     },
     async ({ action, path: assetPath, assetId, jobId, kind, limit, title, narrative, prompt, image, model, provider, language, region, n, ratio, width, height, duration, maxPages, maxChars, attach }) => {

package/src/store/orama-store.ts

@@ -587,7 +587,9 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
 
   // Orama's vector/hybrid search can leak cross-project hits even when `where`
   // is present, so always keep enough headroom for a deterministic post-filter.
-  const requestLimit = projectIds
+  // Session dedup demotes already-surfaced entries after ranking, so it needs
+  // the same headroom to let unseen candidates rise into the final limit.
+  const requestLimit = projectIds || (options.surfacedIds && options.surfacedIds.length > 0)
     ? (options.limit ?? 20) * 3
     : (options.limit ?? 20);
 
@@ -902,6 +904,20 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
     intermediate.sort((a, b) => b.score - a.score);
   }
 
+  // ── Session dedup (demote, never remove) ────────────────────────
+  // Entries already surfaced earlier in the same session are demoted so
+  // unseen evidence can rise into the final limit. A demoted entry is never
+  // removed: when it is the strong match for a new question, it still wins
+  // on score and answers that turn.
+  if (options.surfacedIds && options.surfacedIds.length > 0) {
+    const SURFACED_PENALTY = 0.5;
+    const surfaced = new Set(options.surfacedIds);
+    intermediate = intermediate.map(entry =>
+      surfaced.has(entry.id) ? { ...entry, score: (entry.score ?? 0) * SURFACED_PENALTY } : entry,
+    );
+    intermediate.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  }
+
   // Temporal filtering: since/until date range
   if (options.since) {
     const sinceDate = new Date(options.since).getTime();

package/src/types.ts

@@ -317,6 +317,12 @@ export interface SearchOptions {
   trackAccess?: boolean;
   /** Internal reader context for agent-facing visibility filtering. */
   reader?: ObservationReader;
+  /**
+   * Observation ids already surfaced earlier in the same session. Surfaced
+   * entries are demoted (never removed) so unseen evidence can rise into the
+   * result limit; a strong match still answers a new question.
+   */
+  surfacedIds?: number[];
   /**
    * `fast` stays fully local, `balanced` (default) permits embeddings, and
    * `thorough` explicitly permits optional LLM query rewrite and reranking.
@@ -654,7 +660,7 @@ export interface MemoryRef {
 /** MCP config format adapter interface */
 export interface MCPConfigAdapter {
   /** Setup-only adapters may support a host that does not participate in workspace sync. */
-  readonly source: AgentTarget | 'codebuddy';
+  readonly source: AgentTarget | 'codebuddy' | 'dsh';
   /** Parse MCP server entries from a config file */
   parse(content: string): MCPServerEntry[];
   /** Generate config file content from MCP server entries */

package/src/workspace/mcp-adapters/dsh.ts

@@ -0,0 +1,147 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import type { MCPConfigAdapter, MCPServerEntry } from '../../types.js';
+
+/**
+ * DeepSeek Harness (DSH) MCP Configuration Adapter.
+ *
+ * DSH composes its runtime from Cordis patch layers. External MCP servers are
+ * registered as rows of the `@deepseek-ai/dsh-mcp-client` plugin inside a
+ * patch list. The user-level layer that applies to every profile lives at:
+ *
+ *   $DSH_HOME/cordis.patch.yml   (default: ~/.dsh/cordis.patch.yml)
+ *
+ * Row shape follows DSH's own shipped Memorix reference
+ * (examples/mcp-memory/memorix.cordis.yml in deepseek-ai/deepseek-harness):
+ *
+ *   - insert:
+ *       - id: memory-memorix
+ *         name: '@deepseek-ai/dsh-mcp-client'
+ *         config:
+ *           serverName: memorix
+ *           transport: stdio
+ *           command: memorix
+ *           args: [serve]
+ *
+ * The `cwd` key is deliberately omitted so the MCP child inherits the DSH
+ * process working directory — the workspace DSH was launched from — which is
+ * what keeps Memorix bound to the current Git project.
+ *
+ * Source: https://github.com/deepseek-ai/deepseek-harness/tree/master/packages/mcp/mcp-client
+ */
+
+const MCP_CLIENT_PLUGIN = '@deepseek-ai/dsh-mcp-client';
+const MEMORIX_ROW_ID = 'memory-memorix';
+
+function resolveDshHome(): string {
+  const configured = process.env.DSH_HOME?.trim();
+  if (configured) return configured;
+  return join(homedir(), '.dsh');
+}
+
+function isMemorixRow(row: unknown): row is Record<string, unknown> {
+  if (!row || typeof row !== 'object' || Array.isArray(row)) return false;
+  const record = row as Record<string, unknown>;
+  if (record.name !== MCP_CLIENT_PLUGIN) return false;
+  const config = record.config;
+  return Boolean(
+    config && typeof config === 'object' && !Array.isArray(config)
+    && (config as Record<string, unknown>).serverName === 'memorix',
+  );
+}
+
+function rowToEntry(row: Record<string, unknown>): MCPServerEntry | null {
+  const config = row.config as Record<string, unknown>;
+  if (!config || typeof config !== 'object') return null;
+  const entry: MCPServerEntry = {
+    name: 'memorix',
+    command: typeof config.command === 'string' ? config.command : '',
+    args: Array.isArray(config.args) ? config.args.filter((arg): arg is string => typeof arg === 'string') : [],
+  };
+  if (typeof config.url === 'string' && config.url) entry.url = config.url;
+  if (config.env && typeof config.env === 'object' && !Array.isArray(config.env)) {
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(config.env as Record<string, unknown>)) {
+      if (typeof value === 'string') env[key] = value;
+    }
+    if (Object.keys(env).length > 0) entry.env = env;
+  }
+  if (config.disabled === true) entry.disabled = true;
+  return entry;
+}
+
+/** Flatten one parsed patch document into its row list, tolerating both
+ *  `- insert: [...]` operations and bare row lists. */
+function patchRows(document: unknown): Record<string, unknown>[] {
+  const rows: Record<string, unknown>[] = [];
+  if (!Array.isArray(document)) return rows;
+  for (const item of document) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+    const record = item as Record<string, unknown>;
+    if (Array.isArray(record.insert)) {
+      for (const row of record.insert) {
+        if (row && typeof row === 'object' && !Array.isArray(row)) {
+          rows.push(row as Record<string, unknown>);
+        }
+      }
+      continue;
+    }
+    rows.push(record);
+  }
+  return rows;
+}
+
+export class DshMCPAdapter implements MCPConfigAdapter {
+  readonly source = 'dsh' as const;
+
+  parse(content: string): MCPServerEntry[] {
+    if (!content.trim()) return [];
+    let document: unknown;
+    try {
+      document = parseYaml(content);
+    } catch {
+      return [];
+    }
+    return patchRows(document)
+      .filter(isMemorixRow)
+      .map(rowToEntry)
+      .filter((entry): entry is MCPServerEntry => entry !== null);
+  }
+
+  generate(servers: MCPServerEntry[]): string {
+    const rows = servers
+      .filter((server) => server.name === 'memorix')
+      .map((server) => {
+        const config: Record<string, unknown> = {
+          serverName: server.name,
+        };
+        if (server.url) {
+          config.transport = 'streamable-http';
+          config.url = server.url;
+          if (server.headers && Object.keys(server.headers).length > 0) config.headers = server.headers;
+        } else {
+          config.transport = 'stdio';
+          config.command = server.command;
+          if (server.args && server.args.length > 0) config.args = server.args;
+          if (server.env && Object.keys(server.env).length > 0) config.env = server.env;
+        }
+        const row: Record<string, unknown> = {
+          id: MEMORIX_ROW_ID,
+          name: MCP_CLIENT_PLUGIN,
+          config,
+        };
+        if (server.disabled === true) row.disabled = true;
+        return row;
+      });
+
+    if (rows.length === 0) return '';
+    return stringifyYaml([{ insert: rows }], { lineWidth: 0 }) + '\n';
+  }
+
+  getConfigPath(_projectRoot?: string): string {
+    return join(resolveDshHome(), 'cordis.patch.yml');
+  }
+}
+
+export { MEMORIX_ROW_ID };

package/src/cli/commands/audit-list.ts

@@ -1,89 +0,0 @@
-/**
- * CLI Command: memorix audit list
- *
- * List all files written by Memorix (audit trail).
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-export default defineCommand({
-  meta: {
-    name: 'list',
-    description: 'List Memorix-written files (audit trail)',
-  },
-  args: {
-    project: {
-      type: 'string',
-      description: 'Filter by project (optional)',
-      required: false,
-    },
-  },
-  run: async ({ args }) => {
-    const { getAllAuditEntries, getProjectId } = await import('../../audit/index.js');
-    const os = await import('node:os');
-    let cwd: string;
-    try {
-      cwd = process.cwd();
-    } catch {
-      cwd = os.homedir();
-      console.log(`[WARN] Could not access current directory, using home: ${cwd}`);
-    }
-
-    p.intro('Memorix Audit Trail');
-
-    const allEntries = await getAllAuditEntries();
-
-    if (allEntries.length === 0) {
-      console.log('No Memorix-written files found.');
-      p.outro('Audit trail is empty.');
-      return;
-    }
-
-    // Filter by project if specified
-    let entries = allEntries;
-    if (args.project) {
-      const targetProjectId = getProjectId(args.project);
-      entries = allEntries.filter((e) => e.projectId === targetProjectId);
-    }
-
-    if (entries.length === 0) {
-      console.log('No Memorix-written files found for this project.');
-      p.outro('Audit trail is empty for this project.');
-      return;
-    }
-
-    // Group by project
-    const byProject: Record<string, Array<{ entry: import('../../audit/index.js').AuditEntry }>> = {};
-    for (const { projectId, entry } of entries) {
-      if (!byProject[projectId]) {
-        byProject[projectId] = [];
-      }
-      byProject[projectId].push({ entry });
-    }
-
-    // Display by project
-    console.log('');
-    for (const [projectId, items] of Object.entries(byProject)) {
-      console.log(`Project: ${projectId}`);
-      console.log('');
-
-      for (const { entry } of items) {
-        const icon = entry.type === 'hook' ? '[HOOK]' : '[TASK]';
-        const agent = entry.agent ? ` (${entry.agent})` : '';
-        console.log(`${icon} ${entry.path}${agent}`);
-        console.log(`   Created: ${entry.createdAt}`);
-        console.log('');
-      }
-    }
-
-    // Summary
-    const hookCount = entries.filter((e) => e.entry.type === 'hook').length;
-    const ruleCount = entries.filter((e) => e.entry.type === 'rule').length;
-    const projectCount = new Set(entries.map((e) => e.projectId)).size;
-
-    p.note(`${projectCount} projects, ${hookCount} hooks, ${ruleCount} rules`);
-
-    p.outro('Audit trail complete.');
-  },
-});

package/src/cli/commands/purge-all-memory.ts

@@ -1,85 +0,0 @@
-/**
- * CLI Command: memorix purge all-memory
- *
- * Delete ALL memories (dangerous operation).
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-export default defineCommand({
-  meta: {
-    name: 'all-memory',
-    description: 'Delete ALL memories (dangerous)',
-  },
-  args: {},
-  run: async ({}) => {
-    p.intro('[WARN]  Purge All Memory');
-
-    // Show warning
-    console.log('');
-    console.log('[WARN]  WARNING: This will delete ALL memories!');
-    console.log('');
-    console.log('This will remove:');
-    console.log('  - All observations from all projects');
-    console.log('  - All entities and relations');
-    console.log('  - All embeddings');
-    console.log('');
-    console.log('This action CANNOT be undone.');
-    console.log('');
-    console.log('Project artifacts (hook files) will be preserved.');
-    console.log('');
-
-    // First confirmation
-    const confirmed1 = await p.confirm({
-      message: 'Are you sure you want to delete ALL memories?',
-    });
-
-    if (p.isCancel(confirmed1) || !confirmed1) {
-      p.outro('Purge cancelled.');
-      return;
-    }
-
-    // Second confirmation (type "DELETE" to confirm)
-    const confirmed2 = await p.text({
-      message: 'Type "DELETE" to confirm:',
-      validate: (value) => {
-        if (value !== 'DELETE') {
-          return 'Please type "DELETE" to confirm';
-        }
-        return undefined;
-      },
-    });
-
-    if (p.isCancel(confirmed2) || confirmed2 !== 'DELETE') {
-      p.outro('Purge cancelled.');
-      return;
-    }
-
-    // Delete all memories
-    try {
-      const {
-        getAllObservations,
-        resolveObservations,
-      } = await import('../../memory/observations.js');
-      const { withFreshIndex } = await import('../../memory/freshness.js');
-      const observations = await withFreshIndex(() => getAllObservations());
-      const ids = observations.map((o) => o.id);
-
-      if (ids.length === 0) {
-        console.log('No observations found.');
-        p.outro('No memories to purge.');
-        return;
-      }
-
-      const result = await resolveObservations(ids, 'archived');
-
-      console.log(`[OK] Archived ${result.resolved.length} observations`);
-
-      p.outro(`All memory purged. ${result.resolved.length} observations archived.`);
-    } catch (err) {
-      console.error(`[ERROR] Failed to purge all memory: ${err}`);
-      p.outro('Purge failed.');
-    }
-  },
-});