memorix 1.4.4 → 1.4.6

package/src/codegraph/auto-context.ts

@@ -29,6 +29,8 @@ import {
 import { CodeGraphStore } from './store.js';
 import { isEligibleForAutomaticDelivery } from '../memory/admission.js';
 import { getSessionResumeBrief } from '../memory/session.js';
+import { listLongTermMemories } from '../memory/long-term.js';
+import { filterReadableObservations } from '../memory/visibility.js';
 import { initSessionStore } from '../store/session-store.js';
 import {
   isContinuationTask,
@@ -94,6 +96,64 @@ function deliveryEligibleProjectObservations(
     .filter((observation) => isEligibleForAutomaticDelivery(observation));
 }
 
+/**
+ * The always-on block: a small "who you are and what this workspace is
+ * doing" context every brief carries, whatever the task. It mirrors the
+ * memory-native feel of a per-session MEMORY.md and stays strictly bounded:
+ * profile 2 lines, latest session 1 line, durable facts 2 lines.
+ */
+async function buildAlwaysOnBlock(input: {
+  dataDir: string;
+  projectId: string;
+  reader: ObservationReader;
+  eligible: ProjectContextObservation[];
+}): Promise<{ profile: string[]; state?: string; durable: string[] }> {
+  // Profile: personal-visibility observations the guidance teaches as
+  // entityName 'user-profile'. Only their owner's reader sees them.
+  const profile = filterReadableObservations(input.eligible, input.reader)
+    .filter(observation => (
+      observation as unknown as { visibility?: string; entityName?: string }
+    ).visibility === 'personal'
+      && (
+        observation as unknown as { entityName?: string }
+      ).entityName === 'user-profile')
+    .slice(0, 2)
+    .map(observation => compactContinuationText(observation.title, 22));
+
+  // Workspace state: the latest completed session with a summary.
+  let state: string | undefined;
+  try {
+    await initSessionStore(input.dataDir);
+    const { getSessionStore } = await import('../store/session-store.js');
+    const sessions = await getSessionStore().loadByProject(input.projectId);
+    const latest = sessions
+      .filter(session => session.endedAt && session.summary?.trim())
+      .sort((a, b) => Date.parse(b.endedAt ?? '') - Date.parse(a.endedAt ?? ''))[0];
+    if (latest?.summary) state = compactContinuationText(latest.summary, 40);
+  } catch { /* session context is optional enrichment */ }
+
+  // Durable facts: the most recently updated approved long-term memories.
+  const durable: string[] = [];
+  try {
+    const items = await listLongTermMemories({
+      dataDir: input.dataDir,
+      reader: {
+        projectId: input.projectId,
+        ...(input.reader.agentId ? { agentId: input.reader.agentId } : {}),
+        ...(input.reader.isTeamMember ? { isTeamMember: true } : {}),
+      },
+      limit: 10,
+    });
+    durable.push(...items
+      .filter(item => item.memory.state === 'approved')
+      .sort((a, b) => (b.memory.updatedAt ?? '').localeCompare(a.memory.updatedAt ?? ''))
+      .slice(0, 2)
+      .map(item => item.memory.kind + ': ' + compactContinuationText(item.memory.title, 22)));
+  } catch { /* long-term memory is optional enrichment */ }
+
+  return { profile, state, durable };
+}
+
 function decideRefresh(input: {
   mode: AutoContextRefreshMode;
   status: ReturnType<CodeGraphStore['status']>;
@@ -356,12 +416,21 @@ export async function buildAutoProjectContext(input: {
       };
     }
   }
+  const alwaysOn = await buildAlwaysOnBlock({
+    dataDir: input.dataDir,
+    projectId: input.project.id,
+    reader: input.reader ?? { projectId: input.project.id },
+    eligible: deliveryEligibleProjectObservations(input.observations, input.project.id),
+  });
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
     dataDir: input.dataDir,
     ...(task ? { task } : {}),
     lens: lens.id,
     startHere,
+    ...(alwaysOn.profile.length > 0 || alwaysOn.state || alwaysOn.durable.length > 0
+      ? { alwaysOn }
+      : {}),
     ...(externalOutline ? { semanticCode: externalOutline } : {}),
     providerQuality,
     currentFacts: worksetFactLines(currentFacts),
@@ -598,6 +667,18 @@ export function formatAutoProjectContextSummary(context: AutoProjectContext): st
     '',
     ...formatCurrentFactsLines(context.currentFacts),
     '',
+  ].filter(Boolean);
+
+  if (context.workset.alwaysOn
+    && (context.workset.alwaysOn.profile.length > 0 || context.workset.alwaysOn.state || context.workset.alwaysOn.durable.length > 0)) {
+    lines.push('You and this workspace');
+    for (const profile of context.workset.alwaysOn.profile.slice(0, 2)) lines.push(`- ${profile}`);
+    if (context.workset.alwaysOn.state) lines.push(`- Recently: ${context.workset.alwaysOn.state}`);
+    for (const durable of context.workset.alwaysOn.durable.slice(0, 2)) lines.push(`- ${durable}`);
+    lines.push('');
+  }
+
+  lines.push(...[
     `- Code memory: ${context.overview.code.files} files / ${context.overview.code.symbols} symbols / ${context.overview.code.refs} memory links`,
     `- Code provider: ${context.providerQuality.selected} (${context.providerQuality.selectedQuality})`,
     `- Languages: ${formatLanguages(context.overview)}`,
@@ -606,7 +687,7 @@ export function formatAutoProjectContextSummary(context: AutoProjectContext): st
     `- Refresh: ${context.refresh.message}`,
     '',
     'Start here',
-  ].filter(Boolean);
+  ].filter(Boolean));
 
   if (startHere.length > 0) {
     startHere.forEach((path, index) => lines.push(`${index + 1}. ${path}`));

package/src/config/yaml-loader.ts

@@ -110,14 +110,9 @@ export interface MemorixYamlConfig {
     workspaceCollection?: string;
   };
 
-  /** Additional MCP servers to aggregate (Memorix as hub) */
-  mcpServers?: Record<string, {
-    type?: 'stdio' | 'sse';
-    command?: string;
-    args?: string[];
-    env?: Record<string, string>;
-    url?: string;
-  }>;
+  // NOTE: a previous `mcpServers` declaration ("Memorix as an MCP hub") was
+  // removed — no code ever consumed it. Unknown top-level keys are ignored,
+  // so existing files with the old key keep loading without error.
 }
 
 // ─── Loader ──────────────────────────────────────────────────────────

package/src/config.ts

@@ -120,10 +120,5 @@ export function getServerConfig(): NonNullable<MemorixYamlConfig['server']> {
   };
 }
 
-/** Team config */
-export function getTeamConfig(): NonNullable<MemorixYamlConfig['team']> {
-  return loadYamlConfig().team ?? {};
-}
-
 /** Get the full resolved YAML config (for status display) */
 export { loadYamlConfig } from './config/yaml-loader.js';

package/src/evaluation/session-replay.ts

@@ -0,0 +1,98 @@
+/**
+ * Session-replay evaluation — deterministic scoring for the retrieval path.
+ *
+ * Purpose: before changing how Memorix retrieves memory, measure the current
+ * behavior with a fixed exam so every later change can be judged by the same
+ * three scores:
+ *
+ *   - hit rate      — the right memory showed up for each question
+ *   - duplicate rate — how much of a session's delivery re-shows the same
+ *                      memory (lower is better; the dedup change targets it)
+ *   - token ceiling  — no turn exceeds its budget
+ *
+ * Scoring is mechanical: ids in, ids out. No model, no network, no keys.
+ */
+
+export interface SessionReplayQuestion {
+  id: string;
+  query: string;
+  /** The observation ids that MUST appear in this turn's results. */
+  expectedObsIds: number[];
+}
+
+export interface SessionReplayTurn {
+  questionId: string;
+  shownObsIds: number[];
+  tokens: number;
+}
+
+export interface SessionReplayScores {
+  questions: number;
+  hits: number;
+  /** hitRate ∈ [0, 1] — share of questions whose expected ids all appeared. */
+  hitRate: number;
+  /** How many times an observation was re-shown after its first appearance. */
+  duplicateShows: number;
+  /** duplicateRate ∈ [0, 1] — duplicate shows / total shows (0 = perfect). */
+  duplicateRate: number;
+  totalShows: number;
+  /** Highest token count across turns. */
+  maxTurnTokens: number;
+  overBudgetTurns: number;
+  turns: SessionReplayTurn[];
+}
+
+export function scoreSessionReplay(
+  questions: SessionReplayQuestion[],
+  turns: SessionReplayTurn[],
+  tokenCeiling: number,
+): SessionReplayScores {
+  const turnById = new Map(turns.map((turn) => [turn.questionId, turn]));
+
+  let hits = 0;
+  let duplicateShows = 0;
+  let totalShows = 0;
+  let maxTurnTokens = 0;
+  let overBudgetTurns = 0;
+  const seen = new Set<number>();
+
+  for (const question of questions) {
+    const turn = turnById.get(question.id);
+    if (!turn) continue;
+    maxTurnTokens = Math.max(maxTurnTokens, turn.tokens);
+    if (turn.tokens > tokenCeiling) overBudgetTurns += 1;
+
+    const expectedFound = question.expectedObsIds.every((id) => turn.shownObsIds.includes(id));
+    if (expectedFound) hits += 1;
+
+    for (const id of turn.shownObsIds) {
+      totalShows += 1;
+      if (seen.has(id)) duplicateShows += 1;
+      seen.add(id);
+    }
+  }
+
+  return {
+    questions: questions.length,
+    hits,
+    hitRate: questions.length === 0 ? 1 : hits / questions.length,
+    duplicateShows,
+    duplicateRate: totalShows === 0 ? 0 : duplicateShows / totalShows,
+    totalShows,
+    maxTurnTokens,
+    overBudgetTurns,
+    turns,
+  };
+}
+
+export function formatSessionReplayScoreboard(scores: SessionReplayScores, label: string): string {
+  const lines = [
+    `Session replay scoreboard — ${label}`,
+    `  questions:        ${scores.questions}`,
+    `  hit rate:         ${scores.hits}/${scores.questions} (${(scores.hitRate * 100).toFixed(0)}%)`,
+    `  duplicate shows:  ${scores.duplicateShows} of ${scores.totalShows} shows (${(scores.duplicateRate * 100).toFixed(0)}%)`,
+    `  max turn tokens:  ${scores.maxTurnTokens}`,
+    `  over-budget:      ${scores.overBudgetTurns} turn(s)`,
+  ];
+  return lines.join('\n');
+}

package/src/git/extractor.ts

@@ -61,8 +61,10 @@ function normalizeCommitCount(count: number): number {
 
 /**
  * Get commit info by hash (or HEAD).
+ * `maxDiffChars` caps how much diff content is captured (default 500).
  */
-export function getCommitInfo(cwd: string, ref = 'HEAD'): CommitInfo {
+export function getCommitInfo(cwd: string, ref = 'HEAD', maxDiffChars = 500): CommitInfo {
+  const cap = Number.isFinite(maxDiffChars) ? Math.max(0, Math.floor(maxDiffChars)) : 500;
   const FORMAT = '%H%n%h%n%aN%n%aI%n%s%n%b';
   const revision = normalizeCommitRef(ref);
   const raw = runGit(cwd, ['log', '-1', `--format=${FORMAT}`, '--end-of-options', revision]).trim();
@@ -93,11 +95,11 @@ export function getCommitInfo(cwd: string, ref = 'HEAD'): CommitInfo {
     }
   }
 
-  // Get short diff summary (first 500 chars of diff)
+  // Get short diff summary, capped at the configured diff-size budget.
   let diffSummary = '';
   try {
     const diff = runGit(cwd, ['diff-tree', '-p', '--no-commit-id', hash], 1024 * 100);
-    diffSummary = diff.substring(0, 500);
+    diffSummary = diff.substring(0, cap);
   } catch { /* diff may be too large */ }
 
   return {

package/src/hooks/installers/index.ts

@@ -360,6 +360,9 @@ const AGENT_SKILL_DIRS: Partial<Record<AgentName, { project: string; global?: st
   kiro: { project: path.join('.kiro', 'skills'), global: path.join('.kiro', 'skills') },
   opencode: { project: path.join('.opencode', 'skills'), global: path.join('.config', 'opencode', 'skills') },
   trae: { project: path.join('.trae', 'skills'), global: path.join('.trae', 'skills') },
+  // DSH's user skill root is <harness home>/skills; the global root below is
+  // resolved to $DSH_HOME (or ~/.dsh) for dsh by installOfficialSkillsForAgent.
+  dsh: { project: path.join('.dsh', 'skills'), global: 'skills' },
 };
 
 const PACKAGE_OWNED_HOOK_AGENTS = new Set<AgentName>(['openclaw', 'hermes', 'omp']);
@@ -384,7 +387,11 @@ async function installOfficialSkillsForAgent(
   const relativeDir = global ? dirs?.global : dirs?.project;
   if (!relativeDir) return [];
 
-  const root = global ? os.homedir() : projectRoot;
+  const root = global
+    ? (agent === 'dsh'
+      ? (process.env.DSH_HOME?.trim() || path.join(os.homedir(), '.dsh'))
+      : os.homedir())
+    : projectRoot;
   const skillPaths: string[] = [];
   for (const skillEntry of OFFICIAL_MEMORIX_SKILLS) {
     const skillPath = path.join(root, relativeDir, skillEntry.name, 'SKILL.md');
@@ -626,6 +633,9 @@ export function getProjectConfigPath(agent: AgentName, projectRoot: string): str
     case 'trae':
       // Trae has no hooks system — only rules (.trae/rules/project_rules.md)
       return path.join(projectRoot, '.trae', 'rules', 'project_rules.md');
+    case 'dsh':
+      // DeepSeek Harness has no hooks system — only guidance (AGENTS.md)
+      return path.join(projectRoot, 'AGENTS.md');
     case 'opencode':
       // OpenCode uses plugin files for hooks
       return path.join(projectRoot, '.opencode', 'plugins', 'memorix.js');
@@ -684,6 +694,9 @@ export function getGlobalConfigPath(agent: AgentName): string {
       return path.join(home, '.omp', 'agent', 'packages', 'memorix', 'extensions', 'memorix.js');
     case 'trae':
       return path.join(home, '.trae', 'rules', 'project_rules.md');
+    case 'dsh':
+      // DSH reads the user-global AGENTS.md from its harness home.
+      return path.join(process.env.DSH_HOME?.trim() || path.join(home, '.dsh'), 'AGENTS.md');
     default:
       return path.join(home, '.memorix', 'hooks.json');
   }
@@ -709,6 +722,9 @@ export function getAgentRulesPath(agent: AgentName, root: string, global = false
         return path.join(root, '.gemini', 'GEMINI.md');
       case 'trae':
         return path.join(root, '.trae', 'rules', 'project_rules.md');
+      case 'dsh':
+        // The user-global AGENTS.md lives in the harness home DSH reads.
+        return path.join(process.env.DSH_HOME?.trim() || path.join(root, '.dsh'), 'AGENTS.md');
       default:
         return path.join(root, '.agent', 'rules', 'memorix.md');
     }
@@ -734,6 +750,8 @@ export function getAgentRulesPath(agent: AgentName, root: string, global = false
       return path.join(root, 'GEMINI.md');
     case 'trae':
       return path.join(root, '.trae', 'rules', 'project_rules.md');
+    case 'dsh':
+      return path.join(root, 'AGENTS.md');
     default:
       return path.join(root, '.agent', 'rules', 'memorix.md');
   }
@@ -842,6 +860,13 @@ export async function detectInstalledAgents(): Promise<AgentName[]> {
     agents.push('trae');
   } catch { /* not installed */ }
 
+  // Check for DeepSeek Harness (its home dir or an explicit DSH_HOME)
+  const dshDir = process.env.DSH_HOME?.trim() || path.join(home, '.dsh');
+  try {
+    await fs.access(dshDir);
+    agents.push('dsh');
+  } catch { /* not installed */ }
+
   return agents;
 }
 
@@ -947,6 +972,22 @@ export async function installHooks(
           generated: { note: 'Trae has no hooks system, only rules (.trae/rules/project_rules.md) installed' },
         };
       }
+    case 'dsh':
+      // DeepSeek Harness has no hook system — install AGENTS.md guidance and
+      // skills; the MCP row is installed by `memorix setup --agent dsh`.
+      {
+        const rulesPath = await installAgentRules(agent, projectRoot, global);
+        const skillPaths = await installOfficialSkillsForAgent(agent, projectRoot, global);
+        return {
+          agent,
+          configPath: rulesPath,
+          events: [],
+          generated: {
+            note: 'DeepSeek Harness has no hook system — installed AGENTS.md guidance and skills; the MCP row is installed by `memorix setup --agent dsh`.',
+            ...(skillPaths.length > 0 ? { skillPaths, skillPath: skillPaths[0] } : {}),
+          },
+        };
+      }
     case 'opencode': {
       // OpenCode uses JS plugin files for hooks
       const pluginContent = generateOpenCodePlugin();
@@ -1127,7 +1168,7 @@ async function installAgentRules(agent: AgentName, projectRoot: string, global =
   try {
     await fs.mkdir(path.dirname(rulesPath), { recursive: true });
 
-    if (agent === 'claude' || agent === 'codex' || agent === 'opencode' || agent === 'antigravity' || agent === 'gemini-cli') {
+    if (agent === 'claude' || agent === 'codex' || agent === 'opencode' || agent === 'antigravity' || agent === 'gemini-cli' || agent === 'dsh') {
       // For shared context files (CLAUDE.md / AGENTS.md / GEMINI.md), append rather than overwrite.
       try {
         const existing = await fs.readFile(rulesPath, 'utf-8');
@@ -1255,13 +1296,28 @@ function getAgentRulesContent(agent?: AgentName, scope: 'project' | 'global' = '
     '- For "why" decisions, use \x60memorix_store_reasoning\x60',
     '- For a stable fact, reusable procedure, or completed episode that merits deliberate long-term review, include \x60longTerm\x60 in \x60memorix_store\x60 with the appropriate kind and normally \x60scope: "project"\x60. It creates a candidate only: do not use it for routine updates, do not make project-derived evidence portable user memory, and do not assume it enters context until an operator qualifies and approves it through \x60memorix memory long-term\x60.',
     '- A \x60user\x60 + \x60portable\x60 durable memory delivered in a task brief is intentionally available across projects. When it matches the task, use it as reusable background even if its origin differs; do not treat it as a current-project fact. Expand it only when needed with \x60memorix_detail\x60 using its \x60durable:<id>\x60 reference and a specific purpose.',
+    '- Record the user profile: the user\u2019s role, expertise, preferences, and goals. Save these with \x60entityName: "user-profile"\x60 and \x60visibility: "personal"\x60 so they stay private and appear in every brief as the "who you are" context.',
     '',
     "**Don't store:** greetings, simple file reads, trivial commands (ls, pwd, git status).",
     '',
+    "**Only store what a future session cannot re-derive.** Code structure, file contents, and Git history are live in the checkout — do not store facts already visible there. A memory earns its place by capturing the why, the context, or a conclusion the checkout alone cannot show.",
+    '',
+    "**Record what worked, not only what failed.** Store validated approaches and explicit user confirmations alongside corrections. Saving only failures drifts behavior away from what the user already accepted; a clear \"yes, that's right\" is feedback worth keeping too.",
+    '',
+    '**Recalled memory is a claim about the past.** A memory naming a specific file, function, or flag describes the past at write time — check the file exists or grep the symbol before recommending it. If the user says to ignore or not use memory, proceed as if memory were empty: do not apply, cite, compare, or mention stored content.',
+    '',
     '## When to resolve memory',
     '',
     'Use \x60memorix_resolve\x60 when a task is done or a bug is fixed. This keeps future searches focused on active work instead of surfacing completed items.',
     '',
+    '## End sessions with a summary',
+    '',
+    'When a session finishes, call \x60memorix_session_end\x60 with a short structured summary so the next agent can resume. Recommended sections:',
+    '- **Goal** — what this session was working on',
+    '- **Discoveries** — findings, gotchas, learnings',
+    '- **Accomplished** — completed items, plus PENDING items for the next session',
+    '- **Relevant Files** — paths and what changed',
+    '',
     '## Tools quick reference',
     '',
     '| Tool | Use when |',

package/src/hooks/types.ts

@@ -41,6 +41,7 @@ export type AgentName =
   | 'hermes'
   | 'opencode'
   | 'trae'
+  | 'dsh'
   | 'pi'
   | 'omp';
 
@@ -61,6 +62,7 @@ export const AGENT_SUPPORT_TIER: Record<AgentName, SupportTier> = {
   hermes: 'community',
   opencode: 'community',
   trae: 'community',
+  dsh: 'community',
   pi: 'community',
   omp: 'community',
   antigravity: 'community',

package/src/integrations/registry.ts

@@ -150,6 +150,15 @@ export const MEMORIX_INTEGRATIONS: MemorixIntegration[] = [
     install: 'memorix setup --agent trae',
     surfaces: ['MCP', 'rules'],
   },
+  {
+    agent: 'dsh',
+    name: 'DeepSeek Harness',
+    entry: 'official-config',
+    status: 'ready',
+    install: 'memorix setup --agent dsh',
+    surfaces: ['MCP', 'AGENTS.md', 'skills'],
+    note: 'DeepSeek Harness support writes a @deepseek-ai/dsh-mcp-client row into $DSH_HOME/cordis.patch.yml (default ~/.dsh/cordis.patch.yml), guidance into the harness AGENTS.md, and skills under $DSH_HOME/skills.',
+  },
   {
     agent: 'memcode',
     name: 'memcode',

package/src/knowledge/workset.ts

@@ -136,6 +136,12 @@ export interface TaskWorkset {
   version: '1.3';
   task: string;
   lens: string;
+  /** Always-on "who you are and what this workspace is doing" block. */
+  alwaysOn?: {
+    profile: string[];
+    state?: string;
+    durable: string[];
+  };
   currentFacts: string[];
   continuation?: WorksetContinuation;
   codeState?: string;
@@ -197,6 +203,12 @@ export interface BuildTaskWorksetInput {
     stale: number;
   };
   runtimeCautions?: WorksetCaution[];
+  /** Always-on "who you are and what this workspace is doing" lines. */
+  alwaysOn?: {
+    profile: string[];
+    state?: string;
+    durable: string[];
+  };
   /** Reader identity used only for team-scoped durable memory filtering. */
   reader?: ObservationReader;
   maxTokens?: number;
@@ -478,6 +490,44 @@ export function renderTaskWorksetPrompt(input: Omit<TaskWorkset, 'prompt' | 'bud
   });
   appendLine(lines, 'Task lens: ' + input.lens, maxTokens, omitted, 'lens');
 
+  // Always-on block: the small "who you are and what this workspace is
+  // doing" context every brief carries, mirroring the memory-native feel of
+  // a per-session MEMORY.md. Lines are pre-truncated by the caller; the
+  // enclosing budget still decides whether they fit.
+  if (input.alwaysOn) {
+    const hasAlwaysOn = input.alwaysOn.profile.length > 0
+      || Boolean(input.alwaysOn.state)
+      || input.alwaysOn.durable.length > 0;
+    if (hasAlwaysOn) {
+      appendLine(lines, '', maxTokens, omitted, 'always-on-heading');
+      appendLine(lines, 'You and this workspace', maxTokens, omitted, 'always-on-heading');
+      for (const profile of input.alwaysOn.profile.slice(0, 2)) {
+        appendLine(lines, '- ' + short(profile, 26), maxTokens, omitted, 'always-on-profile', selected, {
+          kind: 'memory',
+          id: 'profile',
+          reason: 'user profile memory',
+          trust: 'source-backed',
+        });
+      }
+      if (input.alwaysOn.state) {
+        appendLine(lines, '- Recently: ' + short(input.alwaysOn.state, 40), maxTokens, omitted, 'always-on-state', selected, {
+          kind: 'continuation',
+          id: 'workspace-state',
+          reason: 'latest session summary for this workspace',
+          trust: 'historical',
+        });
+      }
+      for (const durable of input.alwaysOn.durable.slice(0, 2)) {
+        appendLine(lines, '- ' + short(durable, 28), maxTokens, omitted, 'always-on-durable', selected, {
+          kind: 'durable-memory',
+          id: 'durable-always',
+          reason: 'recent durable memory for this workspace',
+          trust: 'source-backed',
+        });
+      }
+    }
+  }
+
   const hasContinuation = Boolean(
     input.continuation?.previousSession
       || (input.continuation?.memories.length ?? 0) > 0
@@ -1011,6 +1061,14 @@ export async function buildTaskWorkset(input: BuildTaskWorksetInput): Promise<Ta
     version: '1.3' as const,
     task,
     lens: input.lens,
+    ...(input.alwaysOn
+      && (
+        input.alwaysOn.profile.length > 0
+        || input.alwaysOn.state
+        || input.alwaysOn.durable.length > 0
+      )
+      ? { alwaysOn: input.alwaysOn }
+      : {}),
     currentFacts: input.currentFacts?.map(fact => fact.startsWith('Historical note:')
       ? short(fact, 48)
       : short(fact, 28)).slice(0, 4) ?? [],

package/src/memory/long-term.ts

@@ -511,13 +511,108 @@ export async function supersedeLongTermMemory(input: {
   });
 }
 
+/**
+ * Rule-leg auto qualification: an explicitly requested candidate carries its
+ * own source evidence, so it qualifies immediately instead of waiting for a
+ * manual CLI review. Hook-captured and git-derived candidates keep the
+ * manual review path. The LLM lane (formation) may enrich evaluation on top
+ * of this deterministic rule; no LLM is required for it to work.
+ */
+export async function maybeAutoQualifyLongTermMemory(input: {
+  dataDir: string;
+  id: string;
+  source?: 'agent' | 'git' | 'manual';
+  sourceDetail?: 'explicit' | 'hook' | 'git-ingest';
+}): Promise<LongTermMemory | null> {
+  if (input.source !== 'manual' && input.sourceDetail !== 'explicit') return null;
+  try {
+    return await qualifyLongTermMemory({
+      dataDir: input.dataDir,
+      id: input.id,
+      reason: 'auto-qualified: explicit request carries its own source evidence',
+    });
+  } catch {
+    // Already beyond candidate, or the record no longer exists.
+    return null;
+  }
+}
+
+export interface LongTermMaintenanceResult {
+  archived: number;
+  superseded: number;
+}
+
+/**
+ * Rule-leg self maintenance: stale active records archive themselves, and a
+ * newer record supersedes older ones sharing the same title within the same
+ * scope and kind. Deterministic and offline; the optional LLM lane can layer
+ * semantic consolidation on top later.
+ */
+export async function maintainLongTermMemories(input: {
+  dataDir: string;
+  projectId: string;
+  now?: Date;
+  decayDays?: number;
+}): Promise<LongTermMaintenanceResult> {
+  const now = input.now ?? new Date();
+  const decayDays = input.decayDays ?? 30;
+  const cutoff = now.getTime() - decayDays * 24 * 60 * 60 * 1000;
+  const result: LongTermMaintenanceResult = { archived: 0, superseded: 0 };
+  const store = await createStore(input.dataDir);
+  const all = store.list({ originProjectId: input.projectId });
+
+  // Decay: qualified/approved records with no read or write activity since
+  // the cutoff archive themselves.
+  for (const memory of all) {
+    if (memory.state !== 'qualified' && memory.state !== 'approved') continue;
+    const lastActivity = Date.parse(memory.lastAccessedAt ?? memory.updatedAt);
+    if (!Number.isFinite(lastActivity) || lastActivity >= cutoff) continue;
+    try {
+      await archiveLongTermMemory({
+        dataDir: input.dataDir,
+        id: memory.id,
+        reason: 'auto-archive: no activity since ' + new Date(lastActivity).toISOString().slice(0, 10),
+      });
+      result.archived += 1;
+    } catch { /* already inactive */ }
+  }
+
+  // Supersede: within one scope and kind, records sharing a title keep only
+  // the newest; the rest are retired with a traceable supersededBy link.
+  const groups = new Map<string, LongTermMemory[]>();
+  for (const memory of store.list({ originProjectId: input.projectId })) {
+    if (memory.state !== 'qualified' && memory.state !== 'approved') continue;
+    const key = memory.scope + '\0' + memory.kind + '\0' + memory.title.trim().toLowerCase();
+    const group = groups.get(key) ?? [];
+    group.push(memory);
+    groups.set(key, group);
+  }
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    group.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    const newest = group[0];
+    for (const older of group.slice(1)) {
+      try {
+        await supersedeLongTermMemory({
+          dataDir: input.dataDir,
+          id: older.id,
+          supersededBy: newest.id,
+          reason: 'auto-supersede: a newer record shares the same title',
+        });
+        result.superseded += 1;
+      } catch { /* scope or owner boundary, or already inactive */ }
+    }
+  }
+
+  return result;
+}
+
 export async function listLongTermMemories(input: {
   dataDir: string;
   reader: LongTermMemoryReader;
   includeInactive?: boolean;
   limit?: number;
-}): Promise<Array<{ memory: LongTermMemory; evidence: LongTermMemoryEvidence[] }>> {
-  const store = await createStore(input.dataDir);
+}): Promise<Array<{ memory: LongTermMemory; evidence: LongTermMemoryEvidence[] }>> {  const store = await createStore(input.dataDir);
   return store.list({ limit: input.limit ?? 100 })
     .filter(memory => canReadLongTermMemory(memory, input.reader))
     .filter(memory => input.includeInactive || memory.state !== 'archived' && memory.state !== 'superseded')

package/src/runtime/control-plane-maintenance.ts

@@ -19,6 +19,7 @@ export const CONTROL_PLANE_MAINTENANCE_KINDS: readonly MaintenanceJobKind[] = [
   'knowledge-compile',
   'knowledge-lint',
   'workflow-index',
+  'long-term-maintenance',
 ];
 
 const TARGET_WAIT_RETRY_MS = 30_000;

package/src/runtime/isolated-maintenance.ts

@@ -20,6 +20,7 @@ export const ISOLATED_MAINTENANCE_JOB_KINDS: readonly MaintenanceJobKind[] = [
   'knowledge-compile',
   'knowledge-lint',
   'workflow-index',
+  'long-term-maintenance',
 ];
 const DEFAULT_TIMEOUT_MS = 5 * 60_000;
 const MAX_CHILD_OUTPUT_BYTES = 1_000_000;