memorix 1.1.12 → 1.1.13

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.1.13] - 2026-07-17
+
+### Added
+- **Codex installation proof** -- `memorix doctor agents --agent codex --scope global` now checks the local plugin bundle, Personal marketplace entry, five declared and trusted lifecycle hooks, and the installed/enabled state reported by `codex plugin list`.
+
+### Fixed
+- **Codex plugin version drift** -- Global setup now stamps the copied Codex plugin manifest with the installed Memorix version, so Codex no longer reports the old template version after an upgrade. The source template is covered by a release regression test as well.
+- **Workspace package publish trap** -- `@memorix/ai`, `@memorix/agent-core`, `@memorix/tui`, and `@memorix/memcode` are now explicitly internal workspaces. The root `memorix` package ships their bundled runtime, and the release workflow publishes only that supported public package.
+
 ## [1.1.12] - 2026-07-17
 
 ### Added

package/README.md

@@ -473,3 +473,5 @@ Memorix draws from the MCP ecosystem and prior memory projects such as mcp-memor
 <h2 id="license"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/tags/light/section-license.svg"><img src="assets/tags/section-license.svg" alt="License" height="32" /></picture></h2>
 
 [Apache 2.0](LICENSE)
+
+[![Star History Chart](https://api.star-history.com/image?repos=AVIDS2/memorix&type=Date)](https://star-history.com/#AVIDS2/memorix&Date)

package/README.zh-CN.md

@@ -471,3 +471,5 @@ Memorix 借鉴了 MCP 生态和 mcp-memory-service、MemCP、claude-mem、Mem0
 <h2 id="license"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/tags/light/section-license.svg"><img src="assets/tags/section-license.svg" alt="License" height="32" /></picture></h2>
 
 [Apache 2.0](LICENSE)
+
+[![Star History Chart](https://api.star-history.com/image?repos=AVIDS2/memorix&type=Date)](https://star-history.com/#AVIDS2/memorix&Date)

package/dist/cli/index.js

@@ -3212,7 +3212,7 @@ ${import_picocolors.default.gray(m3)}  ${s2}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.1.12" : pkg.version;
+  return true ? "1.1.13" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -23285,7 +23285,8 @@ __export(setup_exports, {
   installOmpPackage: () => installOmpPackage,
   installOpenClawBundlePackage: () => installOpenClawBundlePackage,
   installPiPackage: () => installPiPackage,
-  installPluginPackage: () => installPluginPackage
+  installPluginPackage: () => installPluginPackage,
+  tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
 import { spawnSync } from "child_process";
 import { existsSync as existsSync9 } from "fs";
@@ -23383,6 +23384,16 @@ async function stripHookCaptureFromPlugin(pluginPath, agent) {
   } catch {
   }
 }
+async function stampCodexPluginVersion(pluginPath) {
+  const manifestPath = path14.join(pluginPath, ".codex-plugin", "plugin.json");
+  const manifest = JSON.parse(await readFile5(manifestPath, "utf-8"));
+  if (manifest.name !== "memorix") {
+    throw new Error(`Unexpected Codex plugin manifest at ${manifestPath}`);
+  }
+  manifest.version = getCliVersion();
+  await writeFile5(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+}
 async function stripHookCaptureFromOpenClawBundle(bundlePath) {
   await rm(path14.join(bundlePath, "hooks"), { recursive: true, force: true });
   const manifestPath = path14.join(bundlePath, ".codex-plugin", "plugin.json");
@@ -23647,6 +23658,7 @@ async function installPluginPackage(options2) {
     const pluginPath2 = path14.join(home, ".codex", "plugins", "memorix");
     const marketplacePath2 = path14.join(home, ".agents", "plugins", "marketplace.json");
     await copyDir(source, pluginPath2);
+    await stampCodexPluginVersion(pluginPath2);
     if (!includeHooks) await stripHookCaptureFromPlugin(pluginPath2, "codex");
     await writeOfficialSkills(path14.join(pluginPath2, "skills"));
     await upsertCodexMarketplace(marketplacePath2, pluginPath2);
@@ -63854,7 +63866,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.1.12" : "1.0.1"
+    version: true ? "1.1.13" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -73908,8 +73920,10 @@ __export(agent_integrations_exports, {
   formatAgentIntegrationReport: () => formatAgentIntegrationReport,
   formatAgentRepairResult: () => formatAgentRepairResult,
   inspectAgentIntegrations: () => inspectAgentIntegrations,
+  parseCodexPluginList: () => parseCodexPluginList,
   repairAgentIntegrations: () => repairAgentIntegrations
 });
+import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync23 } from "fs";
 import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
 import { basename as basename3, dirname as dirname7, resolve as resolve2 } from "path";
@@ -73987,6 +74001,275 @@ function aggregateGuidanceIssues(checks) {
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function asRecordArray(value) {
+  return Array.isArray(value) ? value.map(asRecord2).filter((entry) => entry !== null) : [];
+}
+function codexPluginPath() {
+  return `${homedir32()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
+}
+function codexMarketplacePath() {
+  return `${homedir32()}/.agents/plugins/marketplace.json`;
+}
+function codexConfigPath() {
+  return `${homedir32()}/.codex/config.toml`;
+}
+function normalizeMarketplacePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isMemorixCodexPlugin(value) {
+  return value.pluginId === CODEX_PLUGIN_ID || value.name === CODEX_PLUGIN_NAME && value.marketplaceName === CODEX_PLUGIN_MARKETPLACE;
+}
+function parseCodexPluginList(output) {
+  try {
+    const parsed = asRecord2(JSON.parse(output));
+    if (!parsed) return null;
+    const entries = [...asRecordArray(parsed.installed), ...asRecordArray(parsed.available)];
+    const plugin = entries.find(isMemorixCodexPlugin);
+    if (!plugin) return { installed: false, enabled: false };
+    return {
+      installed: plugin.installed === true,
+      enabled: plugin.enabled === true,
+      ...typeof plugin.version === "string" ? { version: plugin.version } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function inspectCodexPluginBundle() {
+  const pluginPath = codexPluginPath();
+  const manifestPath = `${pluginPath}/.codex-plugin/plugin.json`;
+  const hooksPath = `${pluginPath}/hooks/hooks.json`;
+  if (!existsSync23(pluginPath)) {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: pluginPath,
+      exists: false,
+      status: "missing",
+      issues: ["codex-plugin-bundle-missing"]
+    };
+  }
+  if (!existsSync23(manifestPath)) {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: manifestPath,
+      exists: false,
+      status: "repairable",
+      issues: ["codex-plugin-manifest-missing"]
+    };
+  }
+  let manifest = null;
+  try {
+    manifest = asRecord2(JSON.parse(await readFile7(manifestPath, "utf-8")));
+  } catch {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: manifestPath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-plugin-manifest-unreadable"]
+    };
+  }
+  if (!manifest || manifest.name !== CODEX_PLUGIN_NAME) {
+    return {
+      scope: "global",
+      kind: "bundle",
+      path: manifestPath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-plugin-manifest-invalid"]
+    };
+  }
+  const version2 = typeof manifest.version === "string" ? manifest.version : void 0;
+  const issues = [];
+  if (version2 !== getCliVersion()) issues.push("codex-plugin-version-mismatch");
+  if (manifest.hooks !== "./hooks/hooks.json") issues.push("codex-hook-manifest-missing");
+  let declared = [];
+  if (!existsSync23(hooksPath)) {
+    issues.push("codex-hook-manifest-missing");
+  } else {
+    try {
+      const hooksConfig = asRecord2(JSON.parse(await readFile7(hooksPath, "utf-8")));
+      const hooks = asRecord2(hooksConfig?.hooks);
+      declared = hooks ? Object.keys(hooks) : [];
+      if (CODEX_HOOK_EVENTS.some((event) => !declared.includes(event))) {
+        issues.push("codex-hook-events-missing");
+      }
+    } catch {
+      issues.push("codex-hook-manifest-unreadable");
+    }
+  }
+  return {
+    scope: "global",
+    kind: "bundle",
+    path: pluginPath,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues: unique(issues),
+    ...version2 ? { version: version2 } : {},
+    hooks: { declared, expected: [...CODEX_HOOK_EVENTS] }
+  };
+}
+async function inspectCodexMarketplace() {
+  const marketplacePath = codexMarketplacePath();
+  if (!existsSync23(marketplacePath)) {
+    return {
+      scope: "global",
+      kind: "marketplace",
+      path: marketplacePath,
+      exists: false,
+      status: "missing",
+      issues: ["codex-marketplace-missing"]
+    };
+  }
+  let catalog = null;
+  try {
+    catalog = asRecord2(JSON.parse(await readFile7(marketplacePath, "utf-8")));
+  } catch {
+    return {
+      scope: "global",
+      kind: "marketplace",
+      path: marketplacePath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-marketplace-unreadable"]
+    };
+  }
+  const entry = asRecordArray(catalog?.plugins).find((plugin) => plugin.name === CODEX_PLUGIN_NAME);
+  if (!entry) {
+    return {
+      scope: "global",
+      kind: "marketplace",
+      path: marketplacePath,
+      exists: true,
+      status: "repairable",
+      issues: ["codex-marketplace-entry-missing"]
+    };
+  }
+  const source = asRecord2(entry.source);
+  const sourcePath = typeof source?.path === "string" ? source.path : "";
+  const issues = source?.source === "local" && normalizeMarketplacePath(sourcePath) === ".codex/plugins/memorix" ? [] : ["codex-marketplace-entry-stale"];
+  return {
+    scope: "global",
+    kind: "marketplace",
+    path: marketplacePath,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues
+  };
+}
+function inspectCodexPluginRuntime() {
+  const command = "codex plugin list --marketplace personal --available --json";
+  const result = spawnSync2("codex", ["plugin", "list", "--marketplace", CODEX_PLUGIN_MARKETPLACE, "--available", "--json"], {
+    encoding: "utf-8",
+    stdio: "pipe",
+    shell: process.platform === "win32"
+  });
+  if (result.error || result.status !== 0) {
+    return {
+      scope: "global",
+      kind: "runtime",
+      path: command,
+      exists: false,
+      status: "skipped",
+      issues: ["codex-plugin-runtime-unavailable"]
+    };
+  }
+  const runtime = parseCodexPluginList(String(result.stdout ?? ""));
+  if (!runtime) {
+    return {
+      scope: "global",
+      kind: "runtime",
+      path: command,
+      exists: true,
+      status: "skipped",
+      issues: ["codex-plugin-runtime-unreadable"]
+    };
+  }
+  const issues = [];
+  if (!runtime.installed) issues.push("codex-plugin-not-installed");
+  else if (!runtime.enabled) issues.push("codex-plugin-disabled");
+  return {
+    scope: "global",
+    kind: "runtime",
+    path: command,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues,
+    runtime
+  };
+}
+async function inspectCodexHookTrust() {
+  const configPath = codexConfigPath();
+  if (!existsSync23(configPath)) {
+    return {
+      scope: "global",
+      kind: "hook-trust",
+      path: configPath,
+      exists: false,
+      status: "skipped",
+      issues: ["codex-hook-trust-unavailable"]
+    };
+  }
+  let config2 = "";
+  try {
+    config2 = await readFile7(configPath, "utf-8");
+  } catch {
+    return {
+      scope: "global",
+      kind: "hook-trust",
+      path: configPath,
+      exists: true,
+      status: "skipped",
+      issues: ["codex-hook-trust-unreadable"]
+    };
+  }
+  const trusted = CODEX_HOOK_STATE_NAMES.filter(
+    (event) => config2.includes(`[hooks.state."${CODEX_PLUGIN_ID}:hooks/hooks.json:${event}:`)
+  );
+  const issues = trusted.length === CODEX_HOOK_STATE_NAMES.length ? [] : ["codex-hook-trust-pending"];
+  return {
+    scope: "global",
+    kind: "hook-trust",
+    path: configPath,
+    exists: true,
+    status: issues.length > 0 ? "repairable" : "ok",
+    issues,
+    hookTrust: { trusted, expected: [...CODEX_HOOK_STATE_NAMES] }
+  };
+}
+function aggregatePluginStatus(checks) {
+  if (checks.length === 0) return "skipped";
+  return worstStatus(checks.map((check2) => check2.status));
+}
+function aggregatePluginIssues(checks) {
+  const status = aggregatePluginStatus(checks);
+  if (status === "ok") {
+    return unique(checks.filter((check2) => check2.status === "skipped").flatMap((check2) => check2.issues));
+  }
+  if (status === "repairable") {
+    return unique(checks.filter((check2) => check2.status === "repairable" || check2.status === "missing").flatMap((check2) => check2.issues));
+  }
+  return unique(checks.filter((check2) => check2.status === status).flatMap((check2) => check2.issues));
+}
+async function inspectPlugin(agent, scope) {
+  if (agent !== "codex" || scope === "local" || scope === "project") {
+    return { status: "skipped", issues: [], checks: [] };
+  }
+  const checks = [
+    await inspectCodexPluginBundle(),
+    await inspectCodexMarketplace(),
+    inspectCodexPluginRuntime(),
+    await inspectCodexHookTrust()
+  ];
+  return {
+    status: aggregatePluginStatus(checks),
+    issues: aggregatePluginIssues(checks),
+    checks
+  };
+}
 function looksLikeStaleMemorixCommand(server) {
   const text = [server.command, ...server.args ?? []].join(" ");
   return /[\\/]\.worktrees[\\/]/i.test(text) || /[\\/]dist[\\/]cli[\\/]index\.js/i.test(text);
@@ -74255,10 +74538,11 @@ async function inspectAgentIntegrations(options2 = {}) {
     entries.push({
       agent,
       mcp: await inspectMcp(agent, projectRoot, scope),
-      guidance: await inspectGuidance(agent, projectRoot, scope)
+      guidance: await inspectGuidance(agent, projectRoot, scope),
+      plugin: await inspectPlugin(agent, scope)
     });
   }
-  const entryStatuses = entries.map((entry) => worstStatus([entry.mcp.status, entry.guidance.status]));
+  const entryStatuses = entries.map((entry) => worstStatus([entry.mcp.status, entry.guidance.status, entry.plugin.status]));
   return {
     projectRoot,
     scope,
@@ -74280,10 +74564,11 @@ function formatAgentIntegrationReport(report) {
     ""
   ];
   for (const entry of report.entries) {
-    const status = worstStatus([entry.mcp.status, entry.guidance.status]);
+    const status = worstStatus([entry.mcp.status, entry.guidance.status, entry.plugin.status]);
     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(", ")}`);
   }
   lines.push("");
   lines.push(`Repair: ${report.repairCommand}`);
@@ -74336,6 +74621,39 @@ async function repairAgentIntegrations(options2 = {}) {
     } else {
       skipped.push(`${entry.agent}:guidance`);
     }
+    if (entry.agent === "codex" && entry.plugin.status !== "ok" && entry.plugin.status !== "skipped") {
+      const bundleOrMarketplaceNeedsRepair = entry.plugin.checks.some(
+        (check2) => (check2.kind === "bundle" || check2.kind === "marketplace") && check2.status !== "ok"
+      );
+      const runtime = entry.plugin.checks.find((check2) => check2.kind === "runtime");
+      const hookTrust = entry.plugin.checks.find((check2) => check2.kind === "hook-trust");
+      const needsInstall = runtime?.runtime?.installed === false;
+      const needsManualEnable = runtime?.runtime?.installed === true && runtime.runtime.enabled === false;
+      const needsHookTrust = hookTrust?.status === "repairable";
+      const missingPluginFiles = entry.plugin.checks.some(
+        (check2) => (check2.kind === "bundle" || check2.kind === "marketplace") && check2.status === "missing"
+      );
+      if (needsManualEnable) {
+        skipped.push("codex:plugin:global:enable-in-plugin-browser");
+      }
+      if (needsHookTrust) {
+        skipped.push("codex:plugin:global:review-hooks");
+      }
+      if (bundleOrMarketplaceNeedsRepair || needsInstall) {
+        if ((missingPluginFiles || needsInstall) && !canInstallMissing) {
+          skipped.push("codex:plugin:global:missing");
+        } else {
+          if (!options2.dry) {
+            await installPluginPackage({ agent: "codex" });
+            if (needsInstall) {
+              const install = tryInstallCodexPlugin();
+              if (!install.ok) skipped.push("codex:plugin:global:install-pending");
+            }
+          }
+          changed.push("codex:plugin:global");
+        }
+      }
+    }
   }
   return {
     projectRoot,
@@ -74366,13 +74684,14 @@ function formatAgentRepairResult(result) {
   }
   return lines.join("\n");
 }
-var GUIDANCE_AGENTS;
+var GUIDANCE_AGENTS, CODEX_PLUGIN_NAME, CODEX_PLUGIN_MARKETPLACE, CODEX_PLUGIN_ID, CODEX_HOOK_EVENTS, CODEX_HOOK_STATE_NAMES;
 var init_agent_integrations = __esm({
   "src/cli/commands/agent-integrations.ts"() {
     "use strict";
     init_esm_shims();
     init_installers();
     init_setup();
+    init_version();
     GUIDANCE_AGENTS = /* @__PURE__ */ new Set([
       "claude",
       "codex",
@@ -74385,6 +74704,11 @@ var init_agent_integrations = __esm({
       "opencode",
       "trae"
     ]);
+    CODEX_PLUGIN_NAME = "memorix";
+    CODEX_PLUGIN_MARKETPLACE = "personal";
+    CODEX_PLUGIN_ID = `${CODEX_PLUGIN_NAME}@${CODEX_PLUGIN_MARKETPLACE}`;
+    CODEX_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PostToolUse", "PreCompact", "Stop"];
+    CODEX_HOOK_STATE_NAMES = ["session_start", "user_prompt_submit", "post_tool_use", "pre_compact", "stop"];
   }
 });