memorix 1.4.4 → 1.4.6

package/src/cli/commands/hooks-install.ts

@@ -159,6 +159,7 @@ function getAgentLabel(agent: string): string {
     hermes: 'Hermes Agent',
     omp: 'Oh-my-Pi',
     trae: 'Trae',
+    dsh: 'DeepSeek Harness',
   };
   return labels[agent] || agent;
 }
@@ -177,6 +178,7 @@ function getAgentHint(agent: string): string {
     hermes: 'Hermes plugin hooks; use `memorix setup --agent hermes`',
     omp: 'Oh-my-Pi package hooks; use `memorix setup --agent omp`',
     trae: '.trae/rules/project_rules.md (rules only, no hooks system)',
+    dsh: '~/.dsh/cordis.patch.yml MCP row via `memorix setup --agent dsh` (no hooks system)',
     codex: 'Codex plugin hooks; use `memorix setup --agent codex`',
   };
   return hints[agent] || '';

package/src/cli/commands/hooks-preview.ts

@@ -152,6 +152,7 @@ function estimateFileSize(agent: string, configPath: string): string {
     antigravity: '~2KB',
     opencode: '~3KB',
     trae: '~1KB',
+    dsh: '~1KB',
   };
   return sizes[agent] || '~2KB';
 }
@@ -171,6 +172,8 @@ function getRulesPath(agent: string, cwd: string, global: boolean): string {
         return path.join(home, '.gemini', 'GEMINI.md');
       case 'trae':
         return path.join(home, '.trae', 'rules', 'project_rules.md');
+      case 'dsh':
+        return path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'AGENTS.md');
       default:
         return '';
     }
@@ -186,6 +189,8 @@ function getRulesPath(agent: string, cwd: string, global: boolean): string {
         return path.join(cwd, 'GEMINI.md');
       case 'trae':
         return path.join(cwd, '.trae', 'rules', 'project_rules.md');
+      case 'dsh':
+        return path.join(cwd, 'AGENTS.md');
       default:
         return '';
     }

package/src/cli/commands/ingest-commit.ts

@@ -7,6 +7,37 @@
 
 import { defineCommand } from 'citty';
 import * as p from '@clack/prompts';
+import type { CommitInfo } from '../../git/extractor.js';
+
+export interface GitIngestPolicyInput {
+  ingestOnCommit?: boolean;
+  maxDiffSize?: number;
+}
+
+/**
+ * The documented git policy settings are real gates, not display-only facts:
+ * `ingest_on_commit = false` disables post-commit ingestion, and
+ * `max_diff_size` caps how much diff content is captured into the narrative.
+ */
+export function applyGitIngestPolicy(
+  commit: CommitInfo,
+  policy: GitIngestPolicyInput,
+): { skip: boolean; reason?: string; diffSummary: string } {
+  if (policy.ingestOnCommit === false) {
+    return {
+      skip: true,
+      reason: 'ingest_on_commit is disabled',
+      diffSummary: commit.diffSummary,
+    };
+  }
+  const cap = policy.maxDiffSize;
+  return {
+    skip: false,
+    diffSummary: typeof cap === 'number' && Number.isFinite(cap)
+      ? commit.diffSummary.slice(0, Math.max(0, Math.floor(cap)))
+      : commit.diffSummary,
+  };
+}
 
 export default defineCommand({
   meta: {
@@ -42,13 +73,26 @@ export default defineCommand({
     if (!auto) p.intro(`Ingest commit: ${ref}`);
 
     try {
+      const { getGitConfig } = await import('../../config.js');
+      const gitCfg = getGitConfig();
       const { getCommitInfo, ingestCommit } = await import('../../git/extractor.js');
-      const commit = getCommitInfo(cwd, ref);
+      const commit = getCommitInfo(cwd, ref, gitCfg.maxDiffSize ?? 500);
+
+      // The documented ingest_on_commit gate: post-commit execution stops
+      // here when disabled. An explicit manual run always proceeds.
+      const policy = applyGitIngestPolicy(commit, {
+        ingestOnCommit: gitCfg.ingestOnCommit,
+        maxDiffSize: gitCfg.maxDiffSize,
+      });
+      if (policy.skip && auto) {
+        console.error(`[memorix] Skipped ${commit.shortHash}: ${policy.reason}`);
+        process.exit(0);
+        return;
+      }
+      commit.diffSummary = policy.diffSummary;
 
       // Noise filter: skip low-value commits (typo, format, lockfile, merge, etc.)
       const { shouldFilterCommit } = await import('../../git/noise-filter.js');
-      const { getGitConfig } = await import('../../config.js');
-      const gitCfg = getGitConfig();
       const filterResult = shouldFilterCommit(commit, {
         skipMergeCommits: gitCfg.skipMergeCommits,
         excludePatterns: gitCfg.excludePatterns,

package/src/cli/commands/integrate.ts

@@ -114,6 +114,7 @@ function getAgentLabel(agent: string): string {
     antigravity: 'Antigravity',
     'gemini-cli': 'Gemini CLI',
     trae: 'Trae',
+    dsh: 'DeepSeek Harness',
   };
   return labels[agent] || agent;
 }
@@ -130,6 +131,7 @@ function getAgentHint(agent: string): string {
     antigravity: 'plugin + MCP + hooks + skills',
     'gemini-cli': 'settings + GEMINI.md',
     trae: 'rules',
+    dsh: 'MCP patch + AGENTS.md + skills',
   };
   return hints[agent] || 'integration files';
 }

package/src/cli/commands/memory.ts

@@ -467,6 +467,7 @@ export default defineCommand({
             createManualLongTermMemory,
             getLongTermMemoryDetail,
             listLongTermMemories,
+            maybeAutoQualifyLongTermMemory,
             promoteObservationToLongTermMemory,
             qualifyLongTermMemory,
             supersedeLongTermMemory,
@@ -545,9 +546,15 @@ export default defineCommand({
                 portability: portability(),
                 reader: longTermReader,
               });
+              // Operator-written records carry their own source evidence.
+              const qualified = await maybeAutoQualifyLongTermMemory({
+                dataDir,
+                id: result.memory.id,
+                source: 'manual',
+              });
               emitResult(
-                { project, ...result },
-                `Created long-term memory candidate ${result.memory.id}. Qualify it after checking its evidence.`,
+                { project, ...result, memory: qualified ?? result.memory },
+                `Created long-term memory ${result.memory.id}.`,
                 asJson,
               );
               return;
@@ -576,9 +583,15 @@ export default defineCommand({
                 applicability: asStringArg(args.applicability),
                 reader: longTermReader,
               });
+              // An explicit promote request carries its own source evidence.
+              const qualified = await maybeAutoQualifyLongTermMemory({
+                dataDir,
+                id: result.memory.id,
+                sourceDetail: 'explicit',
+              });
               emitResult(
-                { project, sourceObservationId: observation.id, ...result },
-                `Promoted observation #${observation.id} to long-term memory candidate ${result.memory.id}.`,
+                { project, sourceObservationId: observation.id, ...result, memory: qualified ?? result.memory },
+                `Promoted observation #${observation.id} to long-term memory ${result.memory.id}.`,
                 asJson,
               );
               return;

package/src/cli/commands/purge.ts

@@ -0,0 +1,120 @@
+/**
+ * CLI Command: memorix purge
+ *
+ * Retire memories from retrieval. Project-scoped by default; --all covers
+ * every project. Observations and long-term records are archived (never
+ * hard-deleted) so the audit trail survives. Refuses to run outside a
+ * terminal without --yes.
+ */
+
+import { defineCommand } from 'citty';
+import { detectProject } from '../../project/detector.js';
+import { getProjectDataDir } from '../../store/persistence.js';
+
+export default defineCommand({
+  meta: {
+    name: 'purge',
+    description: 'Retire memories from retrieval (current project by default, --all for every project)',
+  },
+  args: {
+    all: {
+      type: 'boolean',
+      description: 'Purge every project instead of the current one',
+      default: false,
+    },
+    yes: {
+      type: 'boolean',
+      description: 'Skip the interactive confirmation',
+      default: false,
+    },
+    json: {
+      type: 'boolean',
+      description: 'Emit a machine-readable result',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const purgeAll = Boolean(args.all);
+    const yes = Boolean(args.yes);
+    const asJson = Boolean(args.json);
+
+    // Confirmation gate first: a destructive wipe never proceeds in a
+    // non-interactive shell without an explicit --yes.
+    if (!yes && !process.stdin.isTTY) {
+      console.error('[ERROR] Non-interactive environment. Add --yes to confirm.');
+      console.error('[ERROR] Refusing to purge memories without confirmation.');
+      process.exitCode = 1;
+      return;
+    }
+    if (!yes) {
+      const readline = await import('node:readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const question = purgeAll
+        ? 'Retire ALL memories from every project? (y/N) '
+        : 'Retire all memories for this project? (y/N) ';
+      const answer = await new Promise<string>((resolve) => rl.question(question, resolve));
+      rl.close();
+      if (answer.trim().toLowerCase() !== 'y') {
+        console.log('Cancelled.');
+        return;
+      }
+    }
+
+    let projectId: string | null = null;
+    if (!purgeAll) {
+      const project = detectProject();
+      if (!project) {
+        console.error('[ERROR] No .git found — run from a project directory or pass --all.');
+        process.exitCode = 1;
+        return;
+      }
+      projectId = project.id;
+    }
+
+    const dataDir = await getProjectDataDir(projectId ?? '');
+    const { initObservationStore } = await import('../../store/obs-store.js');
+    const { getAllObservations, resolveObservations } = await import('../../memory/observations.js');
+    const { withFreshIndex } = await import('../../memory/freshness.js');
+    await initObservationStore(dataDir);
+
+    const observations = await withFreshIndex(() => getAllObservations());
+    const target = purgeAll ? observations : observations.filter((o) => o.projectId === projectId);
+    const ids = target
+      .map((o) => o.id)
+      .filter((id): id is number => typeof id === 'number');
+    const archived = ids.length > 0
+      ? (await resolveObservations(ids, 'archived')).resolved.length
+      : 0;
+
+    const { LongTermMemoryStore } = await import('../../memory/long-term-store.js');
+    const { archiveLongTermMemory } = await import('../../memory/long-term.js');
+    const longTermStore = new LongTermMemoryStore();
+    await longTermStore.init(dataDir);
+    let longTermArchived = 0;
+    for (const memory of longTermStore.list()) {
+      if (memory.state === 'archived' || memory.state === 'superseded') continue;
+      if (!purgeAll && memory.originProjectId !== projectId) continue;
+      try {
+        await archiveLongTermMemory({
+          dataDir,
+          id: memory.id,
+          reason: purgeAll ? 'purge --all' : 'purge (project) ' + (projectId ?? ''),
+        });
+        longTermArchived += 1;
+      } catch { /* already inactive */ }
+    }
+
+    const result = {
+      scope: purgeAll ? 'all' : projectId,
+      observationsArchived: archived,
+      longTermArchived,
+    };
+    if (asJson) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(
+        `[OK] Purged ${purgeAll ? 'all projects' : result.scope}: archived ${archived} observations and ${longTermArchived} long-term memories.`,
+      );
+    }
+  },
+});

package/src/cli/commands/serve-http.ts

@@ -39,6 +39,36 @@ export function parseSessionTimeoutMs(raw: string | undefined): number {
   return Math.floor(parsed);
 }
 
+export interface ServeHttpConfiguredDefaults {
+  port?: number;
+  transport?: 'stdio' | 'http';
+  dashboard?: boolean;
+  dashboardPort?: number;
+}
+
+/**
+ * The [server] config section is a real default source, not display-only:
+ * `port` becomes the listener default and an explicit `transport: "stdio"`
+ * produces a notice (an explicit serve-http command still wins). CLI flags
+ * always beat config.
+ */
+export function resolveServeHttpDefaults(
+  argsPort: string | undefined,
+  configured: ServeHttpConfiguredDefaults,
+): { port: number; transportNotice?: string } {
+  const configuredPort = typeof configured.port === 'number' && Number.isFinite(configured.port)
+    ? configured.port
+    : undefined;
+  const port = parseTcpPortOrReport(argsPort, configuredPort ?? 3211);
+  if (port === undefined) {
+    return { port: 3211 };
+  }
+  const transportNotice = configured.transport === 'stdio'
+    ? '[memorix] config server.transport = "stdio"; serve-http continues on HTTP (the explicit command wins).'
+    : undefined;
+  return { port, transportNotice };
+}
+
 export default defineCommand({
   meta: {
     name: 'serve-http',
@@ -81,11 +111,15 @@ export default defineCommand({
     const { writeFileSync, mkdirSync } = await import('node:fs');
     const { homedir } = await import('node:os');
 
-    const port = parseTcpPortOrReport(args.port, 3211);
-    if (port === undefined) {
-      process.exitCode = 1;
-      return;
-    }
+    // The [server] config section feeds startup defaults; CLI flags win.
+    let configuredDefaults: ServeHttpConfiguredDefaults = {};
+    try {
+      const { getServerConfig } = await import('../../config.js');
+      configuredDefaults = getServerConfig();
+    } catch { /* config files are optional */ }
+    const resolved = resolveServeHttpDefaults(args.port as string | undefined, configuredDefaults);
+    if (resolved.transportNotice) console.error(resolved.transportNotice);
+    const port = resolved.port;
     const host = args.host || '127.0.0.1';
     const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: 'team' });
 

package/src/cli/commands/setup.ts

@@ -30,6 +30,7 @@ import { OmpMCPAdapter } from '../../workspace/mcp-adapters/omp.js';
 import { KiroMCPAdapter } from '../../workspace/mcp-adapters/kiro.js';
 import { OpenCodeMCPAdapter } from '../../workspace/mcp-adapters/opencode.js';
 import { TraeMCPAdapter } from '../../workspace/mcp-adapters/trae.js';
+import { DshMCPAdapter } from '../../workspace/mcp-adapters/dsh.js';
 import { CodeBuddyMCPAdapter } from '../../workspace/mcp-adapters/codebuddy.js';
 import { getSetupIntegrationRows as readSetupIntegrationRows } from '../../integrations/registry.js';
 import { OFFICIAL_MEMORIX_SKILLS } from '../../hooks/official-skills.js';
@@ -190,6 +191,7 @@ const SUPPORTED_SETUP_AGENTS: AgentName[] = [
   'omp',
   'kiro',
   'trae',
+  'dsh',
   'pi',
 ];
 
@@ -402,6 +404,7 @@ export function getMcpAdapter(agent: McpConfigAgent): MCPConfigAdapter {
     kiro: new KiroMCPAdapter(),
     opencode: new OpenCodeMCPAdapter(),
     trae: new TraeMCPAdapter(),
+    dsh: new DshMCPAdapter(),
   };
   return adapters[agent];
 }
@@ -419,7 +422,9 @@ export function buildMemorixServer(mcp: Exclude<SetupMcpTransport, 'none'>): MCP
   return {
     name: 'memorix',
     command: 'memorix',
-    args: ['serve'],
+    // The installed surface must expose every tool the generated guidance
+    // teaches. lite covers the full taught set; micro would hide half of it.
+    args: ['serve', '--mode', 'lite'],
   };
 }
 
@@ -699,6 +704,55 @@ function mergeYamlMcpConfig(existingContent: string | null, generatedContent: st
   return stringifyYaml(merged, { lineWidth: 0 });
 }
 
+/**
+ * Merge the generated DeepSeek Harness patch rows into an existing
+ * `cordis.patch.yml` without clobbering unrelated user patches.
+ *
+ * DSH patch files are lists of Cordis patch operations. Memorix owns exactly
+ * the `@deepseek-ai/dsh-mcp-client` row whose config.serverName is `memorix`;
+ * every other operation is user-owned and must survive the merge. When the
+ * existing file is not a parseable list, the generated rows are appended to
+ * the raw content instead of overwriting it.
+ */
+function mergeDshPatchConfig(existingContent: string | null, generatedContent: string): string {
+  const generatedTrimmed = generatedContent.trimEnd();
+  if (!existingContent?.trim()) {
+    return generatedTrimmed.endsWith('\n') ? generatedTrimmed : `${generatedTrimmed}\n`;
+  }
+
+  const isMemorixInsertRow = (row: unknown): boolean => {
+    if (!row || typeof row !== 'object' || Array.isArray(row)) return false;
+    const record = row as Record<string, unknown>;
+    if (record.name !== '@deepseek-ai/dsh-mcp-client') return false;
+    const config = record.config;
+    return Boolean(
+      config && typeof config === 'object' && !Array.isArray(config)
+      && (config as Record<string, unknown>).serverName === 'memorix',
+    );
+  };
+
+  const opContainsMemorixRow = (op: unknown): boolean => {
+    if (!op || typeof op !== 'object' || Array.isArray(op)) return false;
+    const insert = (op as Record<string, unknown>).insert;
+    return Array.isArray(insert) && insert.some(isMemorixInsertRow);
+  };
+
+  let existingDocument: unknown;
+  try {
+    existingDocument = parseYaml(existingContent);
+  } catch {
+    return `${existingContent.trimEnd()}\n\n${generatedTrimmed}\n`;
+  }
+  if (!Array.isArray(existingDocument)) {
+    // A scalar or mapping document is not a patch list — never rewrite it.
+    return `${existingContent.trimEnd()}\n\n${generatedTrimmed}\n`;
+  }
+
+  const kept = existingDocument.filter((op) => !opContainsMemorixRow(op));
+  const merged = [...kept, ...(parseYaml(generatedContent) as unknown[])];
+  return stringifyYaml(merged, { lineWidth: 0 }) + '\n';
+}
+
 export async function installMcpConfig(options: {
   agent: McpConfigAgent;
   projectRoot?: string;
@@ -725,7 +779,9 @@ export async function installMcpConfig(options: {
     ? mergeTomlMcpConfig(existingContent, generated)
     : options.agent === 'hermes'
       ? mergeYamlMcpConfig(existingContent, generated)
-    : mergeJsonMcpConfig(existingContent, generated);
+      : options.agent === 'dsh'
+        ? mergeDshPatchConfig(existingContent, generated)
+        : mergeJsonMcpConfig(existingContent, generated);
 
   await mkdir(path.dirname(configPath), { recursive: true });
   await writeFile(configPath, content, 'utf-8');
@@ -1603,7 +1659,7 @@ export default defineCommand({
   args: {
     agent: {
       type: 'string',
-      description: 'Target agent (claude, codex, codebuddy, opencode, cursor, windsurf, copilot, gemini-cli, antigravity, openclaw, hermes, omp, kiro, trae, pi, all)',
+      description: 'Target agent (claude, codex, codebuddy, opencode, cursor, windsurf, copilot, gemini-cli, antigravity, openclaw, hermes, omp, kiro, trae, dsh, pi, all)',
       required: false,
     },
     mcp: {
@@ -1677,6 +1733,7 @@ export default defineCommand({
           { value: 'hermes', label: 'Hermes Agent', hint: 'plugin + hooks + commands + skills + MCP' },
           { value: 'omp', label: 'Oh-my-Pi', hint: 'package + extension + command + MCP' },
           { value: 'pi', label: 'Pi coding agent', hint: 'package + extension + skill' },
+          { value: 'dsh', label: 'DeepSeek Harness', hint: 'MCP patch + AGENTS.md + skills' },
           { value: 'opencode', label: 'OpenCode', hint: 'local plugin + AGENTS.md + MCP' },
           { value: 'windsurf', label: 'Windsurf', hint: 'rules + hooks + MCP' },
           { value: 'all', label: 'All supported agents', hint: 'install detected-compatible files' },

package/src/cli/commands/uninstall.ts

@@ -56,6 +56,15 @@ function checkTOML(p: string): boolean {
   } catch { return false; }
 }
 
+function checkDshPatch(p: string): boolean {
+  if (!exists(p)) return false;
+  try {
+    const content = fs.readFileSync(p, 'utf-8');
+    if (!content.includes('memory-memorix')) return false;
+    return /serverName:\s*['"]?memorix['"]?/.test(content);
+  } catch { return false; }
+}
+
 /** Detects memorix MCP config entries in both global and project-level paths. */
 function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
   const entries: MCPConfigEntry[] = [];
@@ -216,6 +225,17 @@ function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
     note: 'Remove the "memorix" key from mcpServers in this file.',
   });
 
+  // DeepSeek Harness
+  const dshPatchPath = path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'cordis.patch.yml');
+  entries.push({
+    agent: 'DeepSeek Harness',
+    path: dshPatchPath,
+    kind: 'global',
+    format: 'json',
+    detected: checkDshPatch(dshPatchPath),
+    note: 'Remove the memory-memorix insert row from this patch file.',
+  });
+
   return entries;
 }