memorix 1.2.6 → 1.2.8

package/src/cli/commands/agent-integrations.ts

@@ -26,6 +26,8 @@ export interface AgentMcpCheck {
   exists: boolean;
   status: AgentIntegrationStatus;
   issues: string[];
+  /** This endpoint is supplied by an enabled Codex plugin, not config.toml. */
+  managedByPlugin?: boolean;
   server?: {
     transport: 'stdio' | 'http';
     command?: string;
@@ -229,6 +231,10 @@ function codexPluginPath(): string {
   return `${homedir()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
 }
 
+function codexPluginMcpPath(): string {
+  return `${codexPluginPath()}/.mcp.json`;
+}
+
 function codexMarketplacePath(): string {
   return `${homedir()}/.agents/plugins/marketplace.json`;
 }
@@ -267,6 +273,7 @@ async function inspectCodexPluginBundle(): Promise<AgentPluginCheck> {
   const pluginPath = codexPluginPath();
   const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
   const hooksPath = `${pluginPath}/hooks/hooks.json`;
+  const mcpPath = codexPluginMcpPath();
   if (!existsSync(pluginPath)) {
     return {
       scope: 'global',
@@ -317,6 +324,20 @@ async function inspectCodexPluginBundle(): Promise<AgentPluginCheck> {
   if (version !== getCliVersion()) issues.push('codex-plugin-version-mismatch');
   if (manifest.hooks !== './hooks/hooks.json') issues.push('codex-hook-manifest-missing');
 
+  if (!existsSync(mcpPath)) {
+    issues.push('codex-plugin-mcp-manifest-missing');
+  } else {
+    try {
+      const mcpConfig = asRecord(JSON.parse(await readFile(mcpPath, 'utf-8')));
+      const server = coerceMcpServer('memorix', asRecord(mcpConfig?.mcpServers)?.memorix);
+      if (!server || !isRecommendedStdioServer(server)) {
+        issues.push('codex-plugin-mcp-manifest-invalid');
+      }
+    } catch {
+      issues.push('codex-plugin-mcp-manifest-unreadable');
+    }
+  }
+
   let declared: string[] = [];
   if (!existsSync(hooksPath)) {
     issues.push('codex-hook-manifest-missing');
@@ -479,7 +500,9 @@ async function inspectCodexHookTrust(): Promise<AgentPluginCheck> {
     kind: 'hook-trust',
     path: configPath,
     exists: true,
-    status: issues.length > 0 ? 'repairable' : 'ok',
+    // Codex records hook approval only after the user has reviewed it. Memorix
+    // must not treat an intentional, host-owned consent step as a broken setup.
+    status: issues.length > 0 ? 'skipped' : 'ok',
     issues,
     hookTrust: { trusted, expected: [...CODEX_HOOK_STATE_NAMES] },
   };
@@ -562,7 +585,7 @@ function getClaudeLocalConfigPath(): string {
   return `${homedir()}/.claude.json`;
 }
 
-function coerceClaudeLocalServer(name: string, value: unknown): MCPServerEntry | null {
+function coerceMcpServer(name: string, value: unknown): MCPServerEntry | null {
   const entry = asRecord(value);
   if (!entry) return null;
   const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
@@ -626,7 +649,7 @@ async function inspectClaudeLocalMcp(projectRoot: string): Promise<AgentMcpCheck
   }
 
   const servers = asRecord(localProject.project.mcpServers);
-  const server = coerceClaudeLocalServer('memorix', servers?.memorix);
+  const server = coerceMcpServer('memorix', servers?.memorix);
   if (!server) {
     return {
       scope: 'local',
@@ -683,6 +706,59 @@ async function installClaudeLocalMcpConfig(projectRoot: string): Promise<void> {
   await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
 }
 
+async function inspectCodexPluginMcp(): Promise<AgentMcpCheck | null> {
+  const runtime = inspectCodexPluginRuntime();
+  if (!runtime.runtime?.installed || !runtime.runtime.enabled) return null;
+
+  const mcpPath = codexPluginMcpPath();
+  if (!existsSync(mcpPath)) {
+    return {
+      scope: 'global',
+      path: mcpPath,
+      exists: false,
+      status: 'repairable',
+      issues: ['codex-plugin-mcp-manifest-missing'],
+      managedByPlugin: true,
+    };
+  }
+
+  try {
+    const config = asRecord(JSON.parse(await readFile(mcpPath, 'utf-8')));
+    const server = coerceMcpServer('memorix', asRecord(config?.mcpServers)?.memorix);
+    if (!server) {
+      return {
+        scope: 'global',
+        path: mcpPath,
+        exists: true,
+        status: 'repairable',
+        issues: ['codex-plugin-mcp-manifest-invalid'],
+        managedByPlugin: true,
+      };
+    }
+    const issues: string[] = [];
+    if (looksLikeStaleMemorixCommand(server)) issues.push('stale-command-path');
+    if (!isRecommendedStdioServer(server)) issues.push('nonstandard-mcp-command');
+    return {
+      scope: 'global',
+      path: mcpPath,
+      exists: true,
+      status: issues.length > 0 ? 'repairable' : 'ok',
+      issues,
+      managedByPlugin: true,
+      server: sanitizeServer(server),
+    };
+  } catch {
+    return {
+      scope: 'global',
+      path: mcpPath,
+      exists: true,
+      status: 'repairable',
+      issues: ['codex-plugin-mcp-manifest-unreadable'],
+      managedByPlugin: true,
+    };
+  }
+}
+
 async function inspectMcp(agent: AgentName, projectRoot: string, scope: AgentIntegrationScope): Promise<AgentIntegrationEntry['mcp']> {
   if (!isMcpConfigAgent(agent)) {
     return { status: 'skipped', issues: ['mcp-managed-by-package'], checks: [] };
@@ -697,6 +773,14 @@ async function inspectMcp(agent: AgentName, projectRoot: string, scope: AgentInt
       continue;
     }
 
+    if (agent === 'codex' && targetScope === 'global') {
+      const pluginCheck = await inspectCodexPluginMcp();
+      if (pluginCheck) {
+        checks.push(pluginCheck);
+        continue;
+      }
+    }
+
     const configPath = adapter.getConfigPath(targetScope === 'project' ? projectRoot : undefined);
     if (targetScope === 'global' && configPath === adapter.getConfigPath(projectRoot)) continue;
 
@@ -872,11 +956,20 @@ export function formatAgentIntegrationReport(report: AgentIntegrationReport): st
     lines.push(`${entry.agent}: ${status}`);
     if (entry.mcp.issues.length > 0) lines.push(`  MCP: ${entry.mcp.issues.join(', ')}`);
     if (entry.guidance.issues.length > 0) lines.push(`  Guidance: ${entry.guidance.issues.join(', ')}`);
-    if (entry.plugin.issues.length > 0) lines.push(`  Plugin: ${entry.plugin.issues.join(', ')}`);
+    const hookTrustPending = entry.plugin.issues.includes('codex-hook-trust-pending');
+    const pluginIssues = entry.plugin.issues.filter((issue) => issue !== 'codex-hook-trust-pending');
+    if (pluginIssues.length > 0) lines.push(`  Plugin: ${pluginIssues.join(', ')}`);
+    if (hookTrustPending) {
+      lines.push('  Hooks: waiting for Codex approval on first use; MCP remains available.');
+    }
   }
 
   lines.push('');
-  lines.push(`Repair: ${report.repairCommand}`);
+  if (report.summary.missing > 0 || report.summary.repairable > 0) {
+    lines.push(`Repair: ${report.repairCommand}`);
+  } else {
+    lines.push('No file repair needed.');
+  }
   return lines.join('\n');
 }
 
@@ -899,6 +992,10 @@ export async function repairAgentIntegrations(options: {
     if (isMcpConfigAgent(entry.agent)) {
       for (const check of entry.mcp.checks) {
         if (check.status === 'ok' || check.status === 'skipped') continue;
+        if (check.managedByPlugin) {
+          skipped.push(`${entry.agent}:mcp:${check.scope}:plugin-managed`);
+          continue;
+        }
         if (check.status === 'missing' && !canInstallMissing) {
           skipped.push(`${entry.agent}:mcp:${check.scope}:missing`);
           continue;

package/src/cli/commands/checkpoint.ts

@@ -0,0 +1,144 @@
+import { defineCommand } from 'citty';
+import { buildCompactionWorkset } from '../../memory/compaction.js';
+import { CompactionCheckpointStore } from '../../store/compaction-checkpoint-store.js';
+import type { CompactionCheckpoint } from '../../types.js';
+import {
+  emitError,
+  emitResult,
+  getCliProjectContext,
+  parsePositiveInt,
+  shortId,
+} from './operator-shared.js';
+
+async function getCheckpointContext() {
+  const context = await getCliProjectContext();
+  const { initAliasRegistry, registerAlias } = await import('../../project/aliases.js');
+  initAliasRegistry(context.dataDir);
+  const canonicalId = await registerAlias(context.project);
+  return {
+    ...context,
+    project: { ...context.project, id: canonicalId },
+    store: new CompactionCheckpointStore(context.dataDir),
+  };
+}
+
+function assertProjectCheckpoint(
+  checkpoint: CompactionCheckpoint | undefined,
+  projectId: string,
+  id: string,
+): CompactionCheckpoint {
+  if (!checkpoint || checkpoint.projectId !== projectId) {
+    throw new Error(`No compact checkpoint "${id}" exists for this project.`);
+  }
+  return checkpoint;
+}
+
+function formatCheckpoint(checkpoint: CompactionCheckpoint): string {
+  const completion = checkpoint.completedAt ? `, completed ${checkpoint.completedAt}` : '';
+  const delivery = checkpoint.deliveredAt ? `, delivered ${checkpoint.deliveryCount}x` : '';
+  return [
+    `${shortId(checkpoint.id)} ${checkpoint.phase} ${checkpoint.agent} (${checkpoint.captureKind}, ${checkpoint.reason})`,
+    `  session: ${checkpoint.sessionId}`,
+    `  source: ${checkpoint.sourceEvent}${completion}${delivery}`,
+    `  status: ${checkpoint.status}${checkpoint.transcriptAvailable ? ', transcript marker available' : ''}`,
+    ...(checkpoint.summary ? [`  summary: ${checkpoint.summary.replace(/\s+/g, ' ').slice(0, 220)}`] : []),
+  ].join('\n');
+}
+
+function usage(): void {
+  console.log('Memorix Compact Checkpoints');
+  console.log('');
+  console.log('Usage:');
+  console.log('  memorix checkpoint list [--session <id>] [--agent <name>] [--all]');
+  console.log('  memorix checkpoint show --id <checkpoint-id>');
+  console.log('  memorix checkpoint context [--id <checkpoint-id>] [--task "..."] [--budget 420]');
+  console.log('  memorix checkpoint archive --id <checkpoint-id>');
+}
+
+export default defineCommand({
+  meta: {
+    name: 'checkpoint',
+    description: 'Inspect and manage native compact continuity checkpoints',
+  },
+  args: {
+    id: { type: 'string', description: 'Checkpoint ID' },
+    session: { type: 'string', description: 'Filter by host session ID' },
+    agent: { type: 'string', description: 'Filter by host agent name' },
+    task: { type: 'string', description: 'Current task for a bounded continuation workset' },
+    budget: { type: 'string', description: 'Maximum workset token budget (default: 420)' },
+    limit: { type: 'string', description: 'Maximum checkpoints to list (default: 20)' },
+    all: { type: 'boolean', description: 'Include archived checkpoints in list output' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const positional = (args._ as string[]) ?? [];
+    const action = (positional[0] ?? 'list').toLowerCase();
+    const asJson = Boolean(args.json);
+
+    try {
+      const { project, store } = await getCheckpointContext();
+      const id = (args.id as string | undefined)?.trim();
+
+      switch (action) {
+        case 'list': {
+          const checkpoints = store.list({
+            projectId: project.id,
+            sessionId: (args.session as string | undefined)?.trim() || undefined,
+            agent: (args.agent as string | undefined)?.trim() || undefined,
+            includeArchived: Boolean(args.all),
+            limit: parsePositiveInt(args.limit as string | undefined, 20),
+          });
+          emitResult(
+            { project, checkpoints },
+            checkpoints.length
+              ? checkpoints.map(formatCheckpoint).join('\n\n')
+              : 'No compact checkpoints for this project.',
+            asJson,
+          );
+          return;
+        }
+
+        case 'show': {
+          if (!id) throw new Error('id is required for "memorix checkpoint show".');
+          const checkpoint = assertProjectCheckpoint(store.get(id), project.id, id);
+          emitResult({ project, checkpoint }, formatCheckpoint(checkpoint), asJson);
+          return;
+        }
+
+        case 'context': {
+          const checkpoint = id
+            ? assertProjectCheckpoint(store.get(id), project.id, id)
+            : store.list({
+              projectId: project.id,
+              sessionId: (args.session as string | undefined)?.trim() || undefined,
+              agent: (args.agent as string | undefined)?.trim() || undefined,
+              limit: parsePositiveInt(args.limit as string | undefined, 20),
+            }).find((entry) => entry.phase === 'complete');
+          if (!checkpoint) {
+            throw new Error('No completed compact checkpoint is available for this project and filter.');
+          }
+          const workset = buildCompactionWorkset(checkpoint, {
+            task: (args.task as string | undefined)?.trim(),
+            maxTokens: parsePositiveInt(args.budget as string | undefined, 420),
+          });
+          emitResult({ project, checkpoint, workset }, workset.text, asJson);
+          return;
+        }
+
+        case 'archive': {
+          if (!id) throw new Error('id is required for "memorix checkpoint archive".');
+          assertProjectCheckpoint(store.get(id), project.id, id);
+          const checkpoint = store.archive(id);
+          if (!checkpoint) throw new Error(`Compact checkpoint "${id}" is already archived.`);
+          emitResult({ project, checkpoint }, `Archived compact checkpoint ${shortId(checkpoint.id)}.`, asJson);
+          return;
+        }
+
+        default:
+          usage();
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

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

@@ -839,10 +839,21 @@ export default defineCommand({
             };
           } catch { /* best effort */ }
 
-          let vectorStatus = { total: 0, missing: 0, missingIds: [] as number[], backfillRunning: false };
+          let vectorStatus = {
+            available: false,
+            total: 0,
+            missing: 0,
+            missingIds: [] as number[],
+            backfillRunning: false,
+          };
           try {
-            const { getVectorStatus } = await import('../../memory/observations.js');
-            vectorStatus = getVectorStatus(statsProjectId);
+            const { getSearchIndexStatus, getVectorStatus } = await import('../../memory/observations.js');
+            // The HTTP control plane has a different module graph from stdio MCP.
+            // Only report vector counts when this process actually owns a hydrated
+            // index; an empty singleton must not look like a healthy 0/0 state.
+            if (getSearchIndexStatus(statsProjectId).prepared) {
+              vectorStatus = { available: true, ...getVectorStatus(statsProjectId) };
+            }
           } catch { /* best effort */ }
 
           // Real search mode from the last actual search execution

package/src/cli/commands/setup.ts

@@ -484,6 +484,40 @@ function mergeTomlMcpConfig(existingContent: string | null, generatedContent: st
   return `${parts.join('\n\n')}\n`;
 }
 
+function isLegacyCodexMemorixNodeServer(server: MCPServerEntry): boolean {
+  if (server.name !== 'memorix' || server.command.trim().toLowerCase() !== 'node') return false;
+  const startsMemorixStdio = server.args.some((arg) => arg.trim().toLowerCase() === 'serve');
+  const sourceEntry = server.args.some((arg) => {
+    const normalized = arg.replace(/\\/g, '/').toLowerCase();
+    return /\/memorix\/dist\/cli\/index\.(?:[cm]?js)$/.test(normalized);
+  });
+  return startsMemorixStdio && sourceEntry;
+}
+
+/**
+ * Codex plugins now own Memorix stdio MCP registration. Remove only the old
+ * source-path form emitted by pre-plugin setup, never a user's custom server.
+ */
+export async function removeLegacyCodexMemorixMcpConfig(
+  configPath = path.join(homedir(), '.codex', 'config.toml'),
+): Promise<{ configPath: string; removed: boolean }> {
+  let existingContent: string;
+  try {
+    existingContent = await readFile(configPath, 'utf-8');
+  } catch {
+    return { configPath, removed: false };
+  }
+
+  const adapter = new CodexMCPAdapter();
+  const legacyServer = adapter.parse(existingContent).find(isLegacyCodexMemorixNodeServer);
+  if (!legacyServer) return { configPath, removed: false };
+
+  let nextContent = removeTomlSection(existingContent, 'mcp_servers.memorix.env');
+  nextContent = removeTomlSection(nextContent, 'mcp_servers.memorix');
+  await writeFile(configPath, nextContent ? `${nextContent}\n` : '', 'utf-8');
+  return { configPath, removed: true };
+}
+
 function mergeYamlMcpConfig(existingContent: string | null, generatedContent: string): string {
   let existing: Record<string, unknown> = {};
   try {
@@ -1091,6 +1125,16 @@ export async function installAgentSetup(agent: AgentName, plan: SetupPlan, globa
       const install = tryInstallCodexPlugin();
       if (install.ok) p.log.success(install.message);
       else p.log.warn(install.message);
+      if (install.ok) {
+        try {
+          const migration = await removeLegacyCodexMemorixMcpConfig();
+          if (migration.removed) {
+            p.log.info(`codex: removed legacy source-path MCP config from ${migration.configPath}`);
+          }
+        } catch {
+          p.log.warn('codex: plugin installed, but the legacy MCP config could not be checked');
+        }
+      }
     } else if (agent === 'claude' && result.marketplaceRoot) {
       const install = tryInstallClaudePlugin(result.marketplaceRoot);
       if (install.ok) p.log.success(install.message);

package/src/cli/index.ts

@@ -1050,6 +1050,7 @@ const main = defineCommand({
     resume: () => import('./commands/resume.js').then(m => m.default),
     explain: () => import('./commands/explain.js').then(m => m.default),
     codegraph: () => import('./commands/codegraph.js').then(m => m.default),
+    checkpoint: () => import('./commands/checkpoint.js').then(m => m.default),
     knowledge: () => import('./commands/knowledge.js').then(m => m.default),
     reasoning: () => import('./commands/reasoning.js').then(m => m.default),
     retention: () => import('./commands/retention.js').then(m => m.default),
@@ -1118,7 +1119,7 @@ const main = defineCommand({
     // Detect by checking if the first CLI arg matches a registered subcommand name.
     const firstArg = process.argv[2];
     const knownSubs = ['ask', 'search', 'remember', 'recent', 'help', 'workbench', 'memcode', 'config',
-      'init', 'setup', 'integrate', 'memory', 'context', 'resume', 'explain', 'codegraph', 'knowledge', 'reasoning', 'retention', 'formation', 'audit', 'transfer', 'skills', 'identity',
+      'init', 'setup', 'integrate', 'memory', 'context', 'resume', 'explain', 'codegraph', 'checkpoint', 'knowledge', 'reasoning', 'retention', 'formation', 'audit', 'transfer', 'skills', 'identity',
       'session', 'team', 'task', 'message', 'lock', 'handoff', 'poll',
       'receipt',
       'serve', 'serve-http', 'status', 'sync',
@@ -1161,6 +1162,7 @@ const main = defineCommand({
       console.error('  resume     Resume prior work with one bounded project brief');
       console.error('  explain    Explain where Memorix project context comes from');
       console.error('  codegraph  Refresh/status/context-pack for CodeGraph Memory');
+      console.error('  checkpoint Inspect native compact continuity checkpoints');
       console.error('  knowledge  Review source-backed knowledge pages and project workflows');
       console.error('  reasoning  Store/search decision rationale');
       console.error('  retention  Inspect stale/archive status');

package/src/codegraph/auto-context.ts

@@ -2,7 +2,12 @@ import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { truncateToTokenBudget } from '../compact/token-budget.js';
 import { getResolvedConfig } from '../config/resolved-config.js';
-import { buildTaskWorkset, type TaskWorkset, type WorksetCaution } from '../knowledge/workset.js';
+import {
+  buildTaskWorkset,
+  type TaskWorkset,
+  type WorksetCaution,
+  type WorksetContinuation,
+} from '../knowledge/workset.js';
 import type { ContextDeliveryTarget } from '../knowledge/context-assembly.js';
 import { sanitizeCredentials } from '../memory/secret-filter.js';
 import type { ObservationReader, ProjectInfo } from '../types.js';
@@ -23,7 +28,7 @@ import {
 } from './project-context.js';
 import { CodeGraphStore } from './store.js';
 import { isEligibleForAutomaticDelivery } from '../memory/admission.js';
-import { getSessionResumeBrief, type SessionResumeBrief } from '../memory/session.js';
+import { getSessionResumeBrief } from '../memory/session.js';
 import { initSessionStore } from '../store/session-store.js';
 import {
   isContinuationTask,
@@ -56,7 +61,7 @@ export interface AutoProjectContext {
   refresh: AutoContextRefreshResult;
   providerQuality: CodeGraphProviderQuality;
   /** Present only when the caller asked to continue prior work. */
-  continuation?: SessionResumeBrief;
+  continuation?: WorksetContinuation;
   workset: TaskWorkset;
 }
 
@@ -72,6 +77,7 @@ export interface AutoProjectBrief {
 }
 
 const DEFAULT_MAX_AGE_MS = 10 * 60 * 1000;
+const COMPACT_CHECKPOINT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 
 function activeProjectObservations(
   observations: ProjectContextObservation[],
@@ -134,6 +140,14 @@ export async function buildAutoProjectContext(input: {
   reader?: ObservationReader;
   /** Auto detects continuation language; always is used by the explicit resume path. */
   continuation?: 'auto' | 'always' | 'never';
+  /**
+   * Suppress a checkpoint already delivered through a host-native channel in
+   * this exact session. Other agents and later sessions remain eligible.
+   */
+  excludeCompactionCheckpointFor?: {
+    sessionId: string;
+    agent: string;
+  };
   /**
    * When supplied, a needed refresh is queued instead of running in this
    * request. MCP and hook callers use this to keep their response path fast.
@@ -294,10 +308,34 @@ export async function buildAutoProjectContext(input: {
   // Project Context is also used by lightweight callers that have not touched
   // session APIs yet. Initialize only when continuation was requested so a
   // normal Workset remains independent of session persistence.
-  let continuation: SessionResumeBrief | undefined;
+  let continuation: WorksetContinuation | undefined;
   if (continuationRequested) {
     await initSessionStore(input.dataDir);
     continuation = await getSessionResumeBrief(input.project.id, task, input.reader);
+    const { CompactionCheckpointStore } = await import('../store/compaction-checkpoint-store.js');
+    const checkpoint = new CompactionCheckpointStore(input.dataDir).findLatestCompleted(
+      input.project.id,
+      input.excludeCompactionCheckpointFor
+        ? { excludeSession: input.excludeCompactionCheckpointFor }
+        : undefined,
+    );
+    const completedAtMs = checkpoint ? Date.parse(checkpoint.completedAt ?? checkpoint.preCapturedAt) : Number.NaN;
+    if (
+      checkpoint
+      && Number.isFinite(completedAtMs)
+      && completedAtMs <= now.getTime()
+      && now.getTime() - completedAtMs <= COMPACT_CHECKPOINT_MAX_AGE_MS
+    ) {
+      continuation.compactCheckpoint = {
+        id: checkpoint.id,
+        agent: checkpoint.agent,
+        captureKind: checkpoint.captureKind === 'native-summary' ? 'native-summary' : 'lifecycle',
+        reason: checkpoint.reason,
+        ...(checkpoint.completedAt ? { completedAt: checkpoint.completedAt } : {}),
+        summary: checkpoint.summary
+          ?? 'The host completed context compaction without exposing a native summary. Reconstruct only what the current task needs from current code and durable evidence.',
+      };
+    }
   }
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
@@ -564,7 +602,7 @@ export function formatAutoProjectContextSummary(context: AutoProjectContext): st
   );
 
   const continuation = context.workset.continuation;
-  if (continuation?.previousSession || continuation?.memories.length) {
+  if (continuation?.previousSession || continuation?.memories.length || continuation?.compactCheckpoint) {
     lines.push('', 'Resume from prior work');
     if (continuation.previousSession) {
       const session = continuation.previousSession;
@@ -584,6 +622,14 @@ export function formatAutoProjectContextSummary(context: AutoProjectContext): st
           + detail,
       );
     }
+    if (continuation.compactCheckpoint) {
+      const checkpoint = continuation.compactCheckpoint;
+      lines.push(
+        '- Recent host compact checkpoint ('
+          + [checkpoint.agent, checkpoint.captureKind, checkpoint.reason].join(', ')
+          + '): ' + compactContinuationText(checkpoint.summary, 36),
+      );
+    }
   }
 
   return lines.join('\n');

package/src/dashboard/server.ts

@@ -351,6 +351,17 @@ async function handleApi(
                     sourceCounts,
                     recentObservations: sorted,
                     embedding: embeddingStatus,
+                    // A standalone dashboard has no access to an active MCP
+                    // process's in-memory Orama index. Keep this explicit so the
+                    // UI never presents an empty local singleton as a healthy
+                    // all-vectors-indexed result.
+                    vectorStatus: {
+                        available: false,
+                        total: 0,
+                        missing: 0,
+                        missingIds: [],
+                        backfillRunning: false,
+                    },
                     storage: storageInfo,
                     maintenance,
                     ...(lifecycle ? { lifecycle } : {}),