memorix 1.2.7 → 1.2.8

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.2.8] - 2026-07-27
+
+### Fixed
+- **Recoverable vector backfill** -- Temporary embedding or index failures no longer exhaust a shared background job. Memorix keeps one diagnosable retry with bounded backoff, batches provider requests, and lets a later healthy MCP session resume the same recovery work instead of accumulating permanent failures.
+- **Accurate vector status outside MCP** -- The standalone dashboard and HTTP control plane no longer present an unhydrated in-memory index as a healthy `0 / 0` result. They now explicitly say that vector status belongs to the active MCP session when they cannot observe it.
+- **Codex plugin ownership** -- Agent Doctor recognizes the enabled Codex plugin as the owner of `memorix serve`, reports first-use hook approval as a host consent step instead of a broken install, and avoids suggesting a redundant config repair.
+- **Safe Codex migration** -- `memorix setup --agent codex --global` removes only the known old source-path Memorix MCP entry after the official plugin installation succeeds. Custom user-managed MCP entries remain untouched.
+
 ## [1.2.7] - 2026-07-27
 
 ### Added

package/dist/cli/index.js

@@ -3212,7 +3212,7 @@ ${import_picocolors.default.gray(m3)}  ${s2}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.2.7" : pkg.version;
+  return true ? "1.2.8" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -17184,6 +17184,10 @@ var init_maintenance_jobs = __esm({
         LIMIT 1
       `).get(input.projectId, input.kind, dedupeKey);
           if (existing) {
+            if (input.kind === "vector-backfill" && existing.status === "retry") {
+              this.commit();
+              return rowToJob(existing);
+            }
             const nextRunAfter = Math.min(Number(existing.run_after), runAfter);
             this.db.prepare(`
           UPDATE maintenance_jobs
@@ -17194,6 +17198,26 @@ var init_maintenance_jobs = __esm({
             this.commit();
             return rowToJob(updated);
           }
+          if (input.kind === "vector-backfill") {
+            const failed = this.db.prepare(`
+          SELECT * FROM maintenance_jobs
+          WHERE project_id = ? AND kind = ? AND dedupe_key = ? AND status = 'failed'
+          ORDER BY updated_at DESC
+          LIMIT 1
+        `).get(input.projectId, input.kind, dedupeKey);
+            if (failed) {
+              this.db.prepare(`
+            UPDATE maintenance_jobs
+            SET status = 'pending', attempts = 0, max_attempts = ?, run_after = ?,
+                payload_json = ?, lease_owner = NULL, lease_expires_at = NULL,
+                last_error = NULL, completed_at = NULL, updated_at = ?
+            WHERE id = ?
+          `).run(maxAttempts, runAfter, payloadJson, now3, failed.id);
+              const revived = this.getRow(failed.id);
+              this.commit();
+              return rowToJob(revived);
+            }
+          }
           const id = randomUUID2();
           this.db.prepare(`
         INSERT INTO maintenance_jobs (
@@ -17365,15 +17389,42 @@ var init_maintenance_jobs = __esm({
         const now3 = options2.now ?? Date.now();
         const delayMs = Number.isFinite(options2.delayMs) ? Math.max(0, Math.floor(options2.delayMs)) : 0;
         const payloadJson = options2.payload === void 0 ? null : JSON.stringify(options2.payload);
+        const status = options2.status === "retry" ? "retry" : "pending";
+        const hasLastError = options2.lastError !== void 0;
+        const lastError = hasLastError ? errorText(options2.lastError) : null;
         this.db.prepare(`
       UPDATE maintenance_jobs
-      SET status = 'pending', run_after = ?, attempts = CASE WHEN ? THEN 0 ELSE attempts END,
+      SET status = ?, run_after = ?, attempts = CASE WHEN ? THEN 0 ELSE attempts END,
           payload_json = COALESCE(?, payload_json),
+          last_error = CASE
+            WHEN ? THEN NULL
+            WHEN ? THEN ?
+            ELSE last_error
+          END,
           lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
       WHERE id = ? AND status = 'running' AND lease_owner = ?
-    `).run(now3 + delayMs, options2.resetAttempts ? 1 : 0, payloadJson, now3, id, workerId);
+    `).run(
+          status,
+          now3 + delayMs,
+          options2.resetAttempts ? 1 : 0,
+          payloadJson,
+          options2.clearLastError ? 1 : 0,
+          hasLastError ? 1 : 0,
+          lastError,
+          now3,
+          id,
+          workerId
+        );
         return this.get(id);
       }
+      resolveFailedVectorBackfills(projectId, dedupeKey = "vector-backfill", now3 = Date.now()) {
+        const result = this.db.prepare(`
+      UPDATE maintenance_jobs
+      SET status = 'completed', completed_at = ?, updated_at = ?
+      WHERE project_id = ? AND kind = 'vector-backfill' AND dedupe_key = ? AND status = 'failed'
+    `).run(now3, now3, projectId, dedupeKey);
+        return Number(result.changes ?? 0);
+      }
       fail(id, workerId, error2, now3 = Date.now()) {
         this.begin();
         try {
@@ -17469,6 +17520,9 @@ var init_maintenance_jobs = __esm({
                 delayMs: result.delayMs,
                 resetAttempts: result.resetAttempts,
                 payload: result.payload,
+                status: result.status,
+                lastError: result.lastError,
+                clearLastError: result.clearLastError,
                 now: now3
               });
               return { state: "rescheduled", job: updated2 };
@@ -18447,6 +18501,9 @@ function normalizeEmbeddingFailure(error2) {
     message: raw
   };
 }
+function vectorBackfillError(error2) {
+  return sanitizeCredentials(normalizeEmbeddingFailure(error2).message).slice(0, 1e3);
+}
 function queueVectorBackfill(projectId) {
   const dataDir = projectDir;
   if (!dataDir) return;
@@ -19202,17 +19259,53 @@ async function backfillVectorEmbeddings(options2 = {}) {
   let succeeded = 0;
   let failed = 0;
   let lastFailure;
+  const recordFailure = (message) => {
+    if (!lastFailure) lastFailure = message;
+  };
+  const candidates = [];
+  for (const id of ids) {
+    const observation = observationById.get(id);
+    if (!observation) {
+      vectorMissingIds.delete(id);
+      continue;
+    }
+    candidates.push({
+      id,
+      observation,
+      text: [observation.title, observation.narrative, ...observation.facts].join(" ")
+    });
+  }
   try {
-    for (const id of ids) {
-      const obs = observationById.get(id);
-      if (!obs) {
-        vectorMissingIds.delete(id);
-        continue;
+    if (candidates.length === 0) {
+      return { attempted: ids.length, succeeded, failed };
+    }
+    let embeddings = null;
+    try {
+      const provider2 = await getEmbeddingProvider();
+      if (!provider2) {
+        if (isEmbeddingExplicitlyDisabled()) {
+          for (const candidate2 of candidates) vectorMissingIds.delete(candidate2.id);
+        } else {
+          recordFailure("embedding provider unavailable");
+          failed += candidates.length;
+        }
+      } else {
+        embeddings = await provider2.embedBatch(candidates.map((candidate2) => candidate2.text));
       }
-      const text = [obs.title, obs.narrative, ...obs.facts].join(" ");
-      try {
-        const embedding = await generateEmbedding(text);
-        if (embedding) {
+    } catch (error2) {
+      recordFailure(vectorBackfillError(error2));
+      failed += candidates.length;
+    }
+    if (embeddings) {
+      for (let index = 0; index < candidates.length; index++) {
+        const { id, observation: obs } = candidates[index];
+        const embedding = embeddings[index];
+        if (!embedding || embedding.length === 0) {
+          recordFailure("embedding provider returned no vector");
+          failed++;
+          continue;
+        }
+        try {
           if (!isVectorCompatibleWithCurrentIndex(embedding)) {
             await upgradeVectorSchemaAfterFirstEmbedding(embedding);
           }
@@ -19221,7 +19314,7 @@ async function backfillVectorEmbeddings(options2 = {}) {
             console.error(
               `[memorix] Backfill embedding mismatch for obs-${id}: provider returned ${embedding.length}d, index expects ${vectorDimensions ?? "unknown"}d (kept in queue)`
             );
-            lastFailure = `dimension mismatch: provider returned ${embedding.length}d, index expects ${vectorDimensions ?? "unknown"}d`;
+            recordFailure(`dimension mismatch: provider returned ${embedding.length}d, index expects ${vectorDimensions ?? "unknown"}d`);
             failed++;
             continue;
           }
@@ -19260,15 +19353,10 @@ async function backfillVectorEmbeddings(options2 = {}) {
           await insertObservation(doc);
           vectorMissingIds.delete(id);
           succeeded++;
-        } else if (isEmbeddingExplicitlyDisabled()) {
-          vectorMissingIds.delete(id);
-        } else {
-          lastFailure = "embedding provider unavailable";
+        } catch (error2) {
+          recordFailure(vectorBackfillError(error2));
           failed++;
         }
-      } catch (err) {
-        lastFailure = err instanceof Error ? err.message : String(err);
-        failed++;
       }
     }
   } finally {
@@ -19281,7 +19369,12 @@ async function backfillVectorEmbeddings(options2 = {}) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  return { attempted: ids.length, succeeded, failed };
+  return {
+    attempted: ids.length,
+    succeeded,
+    failed,
+    ...lastFailure ? { lastError: lastFailure } : {}
+  };
 }
 var observations, nextId, projectDir, searchIndexPrepared, vectorMissingIds, vectorBackfillRunning, vectorSchemaUpgradePromise, lastVectorBackfill, embeddingFailureLogTimestamps, EMBEDDING_FAILURE_LOG_COOLDOWN_MS;
 var init_observations = __esm({
@@ -27569,6 +27662,7 @@ __export(setup_exports, {
   installOpenClawBundlePackage: () => installOpenClawBundlePackage,
   installPiPackage: () => installPiPackage,
   installPluginPackage: () => installPluginPackage,
+  removeLegacyCodexMemorixMcpConfig: () => removeLegacyCodexMemorixMcpConfig,
   tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
 import { spawnSync } from "child_process";
@@ -27816,6 +27910,31 @@ function mergeTomlMcpConfig(existingContent, generatedContent) {
   return `${parts.join("\n\n")}
 `;
 }
+function isLegacyCodexMemorixNodeServer(server) {
+  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;
+}
+async function removeLegacyCodexMemorixMcpConfig(configPath = path17.join(homedir24(), ".codex", "config.toml")) {
+  let existingContent;
+  try {
+    existingContent = await readFile5(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 writeFile5(configPath, nextContent ? `${nextContent}
+` : "", "utf-8");
+  return { configPath, removed: true };
+}
 function mergeYamlMcpConfig(existingContent, generatedContent) {
   let existing = {};
   try {
@@ -28297,6 +28416,16 @@ async function installAgentSetup(agent, plan, global2) {
       const install = tryInstallCodexPlugin();
       if (install.ok) v3.success(install.message);
       else v3.warn(install.message);
+      if (install.ok) {
+        try {
+          const migration = await removeLegacyCodexMemorixMcpConfig();
+          if (migration.removed) {
+            v3.info(`codex: removed legacy source-path MCP config from ${migration.configPath}`);
+          }
+        } catch {
+          v3.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) v3.success(install.message);
@@ -68531,6 +68660,26 @@ function vectorBatchSize(payload) {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_VECTOR_BATCH_SIZE;
   return Math.min(100, Math.max(1, Math.floor(value)));
 }
+function vectorBackfillFailureStreak(payload) {
+  const value = payload.vectorBackfillFailureStreak;
+  return typeof value === "number" && Number.isFinite(value) ? Math.min(16, Math.max(0, Math.floor(value))) : 0;
+}
+function vectorBackfillRetryDelayMs(streak) {
+  return Math.min(
+    VECTOR_FAILURE_MAX_RETRY_DELAY_MS,
+    VECTOR_FAILURE_BASE_RETRY_DELAY_MS * 2 ** Math.max(0, streak - 1)
+  );
+}
+function withoutVectorBackfillFailureStreak(payload) {
+  const { vectorBackfillFailureStreak: _streak, ...rest } = payload;
+  return rest;
+}
+function resolveSupersededVectorFailures(projectDir2, projectId) {
+  try {
+    new MaintenanceJobStore(projectDir2).resolveFailedVectorBackfills(projectId);
+  } catch {
+  }
+}
 function retentionBatchSize(payload) {
   const value = payload.limit;
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_RETENTION_BATCH_SIZE;
@@ -68939,20 +69088,45 @@ function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot, op
     if (isEmbeddingExplicitlyDisabled2()) return { action: "complete" };
     const { backfillVectorEmbeddings: backfillVectorEmbeddings2, getVectorStatus: getVectorStatus2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
     const before = getVectorStatus2(projectId);
-    if (before.missing === 0) return { action: "complete" };
+    if (before.missing === 0) {
+      resolveSupersededVectorFailures(projectDir2, projectId);
+      return { action: "complete" };
+    }
     const result = await backfillVectorEmbeddings2({
       projectId,
       limit: vectorBatchSize(job.payload)
     });
     const after = getVectorStatus2(projectId);
-    if (after.missing === 0) return { action: "complete" };
+    if (after.missing === 0) {
+      resolveSupersededVectorFailures(projectDir2, projectId);
+      return { action: "complete" };
+    }
     if (result.failed > 0 && result.succeeded === 0) {
-      throw new Error(`vector backfill made no progress (${result.failed}/${result.attempted} failed)`);
+      const streak = vectorBackfillFailureStreak(job.payload) + 1;
+      return {
+        action: "reschedule",
+        status: "retry",
+        delayMs: vectorBackfillRetryDelayMs(streak),
+        // This is a recoverable provider/index state, not a terminal job error.
+        // Keeping one retry row prevents new MCP processes from creating a storm.
+        resetAttempts: true,
+        payload: {
+          ...job.payload,
+          vectorBackfillFailureStreak: streak
+        },
+        lastError: result.lastError ?? `vector backfill made no progress (${result.failed}/${result.attempted} failed)`
+      };
     }
+    const priorFailureStreak = vectorBackfillFailureStreak(job.payload);
+    const payload = withoutVectorBackfillFailureStreak(job.payload);
     return {
       action: "reschedule",
       delayMs: result.attempted === 0 ? VECTOR_RETRY_DELAY_MS : 0,
-      resetAttempts: result.succeeded > 0
+      resetAttempts: result.succeeded > 0,
+      ...result.succeeded > 0 ? {
+        ...priorFailureStreak > 0 ? { payload } : {},
+        ...result.failed > 0 && result.lastError ? { lastError: result.lastError } : priorFailureStreak > 0 ? { clearLastError: true } : {}
+      } : {}
     };
   };
 }
@@ -68965,11 +69139,12 @@ function createProjectMaintenanceDispatcher(projectId, projectDir2, projectRoot,
     return isolatedRunner({ job, projectRoot, dataDir: projectDir2 });
   };
 }
-var DEFAULT_VECTOR_BATCH_SIZE, DEFAULT_RETENTION_BATCH_SIZE, DEFAULT_CONSOLIDATION_BATCH_SIZE, DEFAULT_CODEGRAPH_MAX_FILES, DEFAULT_CLAIM_DERIVATION_BATCH_SIZE, DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE, VECTOR_RETRY_DELAY_MS, DEDUP_PER_PAIR_TIMEOUT_MS;
+var DEFAULT_VECTOR_BATCH_SIZE, DEFAULT_RETENTION_BATCH_SIZE, DEFAULT_CONSOLIDATION_BATCH_SIZE, DEFAULT_CODEGRAPH_MAX_FILES, DEFAULT_CLAIM_DERIVATION_BATCH_SIZE, DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE, VECTOR_RETRY_DELAY_MS, VECTOR_FAILURE_BASE_RETRY_DELAY_MS, VECTOR_FAILURE_MAX_RETRY_DELAY_MS, DEDUP_PER_PAIR_TIMEOUT_MS;
 var init_project_maintenance = __esm({
   "src/runtime/project-maintenance.ts"() {
     "use strict";
     init_esm_shims();
+    init_maintenance_jobs();
     init_isolated_maintenance();
     init_lifecycle();
     init_timeout();
@@ -68980,6 +69155,8 @@ var init_project_maintenance = __esm({
     DEFAULT_CLAIM_DERIVATION_BATCH_SIZE = 100;
     DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE = 100;
     VECTOR_RETRY_DELAY_MS = 5e3;
+    VECTOR_FAILURE_BASE_RETRY_DELAY_MS = 6e4;
+    VECTOR_FAILURE_MAX_RETRY_DELAY_MS = 15 * 6e4;
     DEDUP_PER_PAIR_TIMEOUT_MS = 5e3;
   }
 });
@@ -69862,6 +70039,17 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           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 } : {},
@@ -71086,7 +71274,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.7" : "1.0.1"
+    version: true ? "1.2.8" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -77462,10 +77650,18 @@ var init_serve_http = __esm({
                 };
               } catch {
               }
-              let vectorStatus = { total: 0, missing: 0, missingIds: [], backfillRunning: false };
+              let vectorStatus = {
+                available: false,
+                total: 0,
+                missing: 0,
+                missingIds: [],
+                backfillRunning: false
+              };
               try {
-                const { getVectorStatus: getVectorStatus2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
-                vectorStatus = getVectorStatus2(statsProjectId);
+                const { getSearchIndexStatus: getSearchIndexStatus2, getVectorStatus: getVectorStatus2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+                if (getSearchIndexStatus2(statsProjectId).prepared) {
+                  vectorStatus = { available: true, ...getVectorStatus2(statsProjectId) };
+                }
               } catch {
               }
               let searchMode = "fulltext";
@@ -82210,6 +82406,9 @@ function asRecordArray(value) {
 function codexPluginPath() {
   return `${homedir32()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
 }
+function codexPluginMcpPath() {
+  return `${codexPluginPath()}/.mcp.json`;
+}
 function codexMarketplacePath() {
   return `${homedir32()}/.agents/plugins/marketplace.json`;
 }
@@ -82242,6 +82441,7 @@ async function inspectCodexPluginBundle() {
   const pluginPath = codexPluginPath();
   const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
   const hooksPath = `${pluginPath}/hooks/hooks.json`;
+  const mcpPath = codexPluginMcpPath();
   if (!existsSync25(pluginPath)) {
     return {
       scope: "global",
@@ -82289,6 +82489,19 @@ async function inspectCodexPluginBundle() {
   const issues = [];
   if (version2 !== getCliVersion()) issues.push("codex-plugin-version-mismatch");
   if (manifest.hooks !== "./hooks/hooks.json") issues.push("codex-hook-manifest-missing");
+  if (!existsSync25(mcpPath)) {
+    issues.push("codex-plugin-mcp-manifest-missing");
+  } else {
+    try {
+      const mcpConfig = asRecord2(JSON.parse(await readFile7(mcpPath, "utf-8")));
+      const server = coerceMcpServer("memorix", asRecord2(mcpConfig?.mcpServers)?.memorix);
+      if (!server || !isRecommendedStdioServer(server)) {
+        issues.push("codex-plugin-mcp-manifest-invalid");
+      }
+    } catch {
+      issues.push("codex-plugin-mcp-manifest-unreadable");
+    }
+  }
   let declared = [];
   if (!existsSync25(hooksPath)) {
     issues.push("codex-hook-manifest-missing");
@@ -82438,7 +82651,9 @@ async function inspectCodexHookTrust() {
     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] }
   };
@@ -82506,7 +82721,7 @@ function defaultClaudeProjectKey(projectRoot) {
 function getClaudeLocalConfigPath() {
   return `${homedir32()}/.claude.json`;
 }
-function coerceClaudeLocalServer(name, value) {
+function coerceMcpServer(name, value) {
   const entry = asRecord2(value);
   if (!entry) return null;
   const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
@@ -82565,7 +82780,7 @@ async function inspectClaudeLocalMcp(projectRoot) {
     };
   }
   const servers = asRecord2(localProject.project.mcpServers);
-  const server = coerceClaudeLocalServer("memorix", servers?.memorix);
+  const server = coerceMcpServer("memorix", servers?.memorix);
   if (!server) {
     return {
       scope: "local",
@@ -82616,6 +82831,56 @@ async function installClaudeLocalMcpConfig(projectRoot) {
   await writeFile7(configPath, `${JSON.stringify(config2, null, 2)}
 `, "utf-8");
 }
+async function inspectCodexPluginMcp() {
+  const runtime = inspectCodexPluginRuntime();
+  if (!runtime.runtime?.installed || !runtime.runtime.enabled) return null;
+  const mcpPath = codexPluginMcpPath();
+  if (!existsSync25(mcpPath)) {
+    return {
+      scope: "global",
+      path: mcpPath,
+      exists: false,
+      status: "repairable",
+      issues: ["codex-plugin-mcp-manifest-missing"],
+      managedByPlugin: true
+    };
+  }
+  try {
+    const config2 = asRecord2(JSON.parse(await readFile7(mcpPath, "utf-8")));
+    const server = coerceMcpServer("memorix", asRecord2(config2?.mcpServers)?.memorix);
+    if (!server) {
+      return {
+        scope: "global",
+        path: mcpPath,
+        exists: true,
+        status: "repairable",
+        issues: ["codex-plugin-mcp-manifest-invalid"],
+        managedByPlugin: true
+      };
+    }
+    const issues = [];
+    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, projectRoot, scope) {
   if (!isMcpConfigAgent(agent)) {
     return { status: "skipped", issues: ["mcp-managed-by-package"], checks: [] };
@@ -82627,6 +82892,13 @@ async function inspectMcp(agent, projectRoot, scope) {
       checks.push(await inspectClaudeLocalMcp(projectRoot));
       continue;
     }
+    if (agent === "codex" && targetScope === "global") {
+      const pluginCheck = await inspectCodexPluginMcp();
+      if (pluginCheck) {
+        checks.push(pluginCheck);
+        continue;
+      }
+    }
     const configPath = adapter.getConfigPath(targetScope === "project" ? projectRoot : void 0);
     if (targetScope === "global" && configPath === adapter.getConfigPath(projectRoot)) continue;
     if (!existsSync25(configPath)) {
@@ -82771,10 +83043,19 @@ function formatAgentIntegrationReport(report) {
     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((issue2) => issue2 !== "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");
 }
 async function repairAgentIntegrations(options2 = {}) {
@@ -82788,6 +83069,10 @@ async function repairAgentIntegrations(options2 = {}) {
     if (isMcpConfigAgent(entry.agent)) {
       for (const check2 of entry.mcp.checks) {
         if (check2.status === "ok" || check2.status === "skipped") continue;
+        if (check2.managedByPlugin) {
+          skipped.push(`${entry.agent}:mcp:${check2.scope}:plugin-managed`);
+          continue;
+        }
         if (check2.status === "missing" && !canInstallMissing) {
           skipped.push(`${entry.agent}:mcp:${check2.scope}:missing`);
           continue;