claude-smart 0.2.25 → 0.2.27

package/bin/claude-smart.js

@@ -12,6 +12,7 @@
 "use strict";
 
 const { execSync, spawn } = require("child_process");
+const crypto = require("crypto");
 const {
   appendFileSync,
   cpSync,
@@ -21,7 +22,8 @@ const {
   rmSync,
   writeFileSync,
 } = require("fs");
-const { homedir } = require("os");
+const https = require("https");
+const { homedir, tmpdir } = require("os");
 const { dirname, join } = require("path");
 
 const DEFAULT_MARKETPLACE_SOURCE = "ReflexioAI/claude-smart";
@@ -52,6 +54,8 @@ const CODEX_REQUIRED_FILES = [
   ".agents/plugins/marketplace.json",
   "plugin/.codex-plugin/plugin.json",
   "plugin/hooks/codex-hooks.json",
+  "plugin/scripts/codex-claude-compat.py",
+  "plugin/scripts/codex-hook.js",
   "plugin/scripts/_codex_env.sh",
 ];
 const CODEX_CLI_TIMEOUT_MS = 30_000;
@@ -175,7 +179,10 @@ function seedReflexioEnv() {
   const existing = existsSync(REFLEXIO_ENV_PATH)
     ? readFileSync(REFLEXIO_ENV_PATH, "utf8")
     : "";
-  const flags = ["CLAUDE_SMART_USE_LOCAL_CLI", "CLAUDE_SMART_USE_LOCAL_EMBEDDING"];
+  const flags = [
+    "CLAUDE_SMART_USE_LOCAL_CLI",
+    "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
+  ];
   const missing = flags.filter((f) => !new RegExp(`^${f}=`, "m").test(existing));
   if (missing.length === 0) return [];
   const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
@@ -184,6 +191,246 @@ function seedReflexioEnv() {
   return missing;
 }
 
+function isWindows() {
+  return process.platform === "win32";
+}
+
+function runChecked(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      shell: isWindows() && /\.(?:cmd|bat)$/i.test(command),
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    child.on("exit", (code) => resolve(typeof code === "number" ? code : 1));
+    child.on("error", () => resolve(1));
+  });
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, (response) => {
+      if (
+        response.statusCode &&
+        response.statusCode >= 300 &&
+        response.statusCode < 400 &&
+        response.headers.location
+      ) {
+        downloadFile(new URL(response.headers.location, url).toString(), dest)
+          .then(resolve, reject);
+        response.resume();
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`download failed (${response.statusCode}) for ${url}`));
+        return;
+      }
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => {
+        writeFileSync(dest, Buffer.concat(chunks));
+        resolve();
+      });
+    });
+    request.on("error", reject);
+    request.setTimeout(120_000, () => request.destroy(new Error(`download timed out for ${url}`)));
+  });
+}
+
+function resolveCommand(names, extraDirs = []) {
+  const pathParts = [
+    ...extraDirs,
+    ...(process.env.PATH || "").split(process.platform === "win32" ? ";" : ":"),
+  ].filter(Boolean);
+  for (const dir of pathParts) {
+    for (const name of names) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function privateNodeRoot() {
+  return join(homedir(), ".claude-smart", "node", "current");
+}
+
+function privateNodeBinDirs() {
+  const root = privateNodeRoot();
+  return [join(root, "bin"), root];
+}
+
+function resolvePrivateNode() {
+  return resolveCommand(isWindows() ? ["node.exe", "node"] : ["node"], privateNodeBinDirs());
+}
+
+function resolvePrivateNpm() {
+  return resolveCommand(
+    isWindows() ? ["npm.cmd", "npm.exe", "npm"] : ["npm"],
+    privateNodeBinDirs(),
+  );
+}
+
+function runtimeEnv(extraDirs = []) {
+  const delimiter = process.platform === "win32" ? ";" : ":";
+  const dirs = [
+    ...extraDirs,
+    ...privateNodeBinDirs(),
+    join(homedir(), ".local", "bin"),
+    join(homedir(), ".cargo", "bin"),
+  ];
+  return {
+    ...process.env,
+    PATH: `${dirs.join(delimiter)}${delimiter}${process.env.PATH || ""}`,
+  };
+}
+
+async function ensureWindowsPrivateNode() {
+  if (!isWindows()) return null;
+  const existing = resolvePrivateNode();
+  const existingNpm = resolvePrivateNpm();
+  if (existing && existingNpm) return { node: existing, npm: existingNpm };
+
+  const major = process.env.CLAUDE_SMART_NODE_LTS_MAJOR || "22";
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  const baseUrl = process.env.CLAUDE_SMART_NODE_BASE_URL || `https://nodejs.org/dist/latest-v${major}.x`;
+  const nodeRoot = join(homedir(), ".claude-smart", "node");
+  const temp = join(tmpdir(), `claude-smart-node-${process.pid}`);
+  mkdirSync(nodeRoot, { recursive: true });
+  rmSync(temp, { recursive: true, force: true });
+  mkdirSync(temp, { recursive: true });
+
+  const sumsPath = join(temp, "SHASUMS256.txt");
+  await downloadFile(`${baseUrl}/SHASUMS256.txt`, sumsPath);
+  const sums = readFileSync(sumsPath, "utf8");
+  const match = sums
+    .split(/\r?\n/)
+    .map((line) => line.trim().split(/\s+/))
+    .find((parts) => parts[1] && new RegExp(`^node-v[^ ]+-win-${arch}\\.zip$`).test(parts[1]));
+  if (!match) throw new Error(`could not resolve Node.js win-${arch} archive from ${baseUrl}`);
+  const [expectedHash, archiveName] = match;
+  const archivePath = join(temp, archiveName);
+  await downloadFile(`${baseUrl}/${archiveName}`, archivePath);
+  const actualHash = crypto.createHash("sha256").update(readFileSync(archivePath)).digest("hex");
+  if (actualHash !== expectedHash) {
+    throw new Error(`Node.js checksum verification failed for ${archiveName}`);
+  }
+
+  const powershell = resolveCommand(["powershell.exe", "powershell", "pwsh"]);
+  if (!powershell) throw new Error("PowerShell is required to extract private Node.js on Windows");
+  const extractDir = join(temp, "extract");
+  mkdirSync(extractDir, { recursive: true });
+  const code = await runChecked(
+    powershell,
+    [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      "$ProgressPreference='SilentlyContinue'; Expand-Archive -LiteralPath $env:ARCHIVE_PATH -DestinationPath $env:DEST_DIR -Force",
+    ],
+    { env: { ...process.env, ARCHIVE_PATH: archivePath, DEST_DIR: extractDir } },
+  );
+  if (code !== 0) throw new Error(`Node.js archive extraction failed for ${archiveName}`);
+  const extracted = join(extractDir, archiveName.replace(/\.zip$/, ""));
+  const current = privateNodeRoot();
+  rmSync(current, { recursive: true, force: true });
+  cpSync(extracted, current, { recursive: true, force: true });
+  rmSync(temp, { recursive: true, force: true });
+
+  const node = resolvePrivateNode();
+  const npm = resolvePrivateNpm();
+  if (!node || !npm) throw new Error("private Node.js install completed but node/npm are not usable");
+  return { node, npm };
+}
+
+function resolveUv() {
+  return resolveCommand(isWindows() ? ["uv.exe", "uv"] : ["uv"], [
+    join(homedir(), ".local", "bin"),
+    join(homedir(), ".cargo", "bin"),
+  ]);
+}
+
+async function ensureWindowsUv() {
+  let uv = resolveUv();
+  if (uv) return uv;
+  const powershell = resolveCommand(["powershell.exe", "powershell", "pwsh"]);
+  if (!powershell) throw new Error("PowerShell is required to install uv on Windows");
+  const code = await runChecked(powershell, [
+    "-NoProfile",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    "irm https://astral.sh/uv/install.ps1 | iex",
+  ]);
+  if (code !== 0) throw new Error("uv install via PowerShell failed");
+  uv = resolveUv();
+  if (!uv) throw new Error("uv install reported success but uv.exe was not found");
+  return uv;
+}
+
+function quoteCommandPart(part) {
+  return `"${String(part).replace(/"/g, '\\"')}"`;
+}
+
+function patchCodexHooksForWindows(pluginRoot, nodePath) {
+  const hookPath = join(pluginRoot, "hooks", "codex-hooks.json");
+  const parsed = JSON.parse(readFileSync(hookPath, "utf8"));
+  const runner = join(pluginRoot, "scripts", "codex-hook.js");
+  const command = (...args) => [nodePath, runner, ...args].map(quoteCommandPart).join(" ");
+  const sessionHooks = parsed.hooks.SessionStart?.[0]?.hooks || [];
+  if (sessionHooks[0]) sessionHooks[0].command = command("ensure-root");
+  if (sessionHooks[1]) sessionHooks[1].command = command("backend");
+  if (sessionHooks[2]) sessionHooks[2].command = command("dashboard");
+  if (sessionHooks[3]) sessionHooks[3].command = command("hook", "session-start");
+  const userPrompt = parsed.hooks.UserPromptSubmit?.[0]?.hooks?.[0];
+  if (userPrompt) userPrompt.command = command("hook", "user-prompt");
+  const postTool = parsed.hooks.PostToolUse?.[0]?.hooks?.[0];
+  if (postTool) postTool.command = command("hook", "post-tool");
+  const stop = parsed.hooks.Stop?.[0]?.hooks?.[0];
+  if (stop) stop.command = command("hook", "stop");
+  writeFileSync(hookPath, JSON.stringify(parsed, null, 2) + "\n");
+}
+
+function ensureWindowsPluginRoot(pluginRoot) {
+  const reflexioDir = dirname(REFLEXIO_ENV_PATH);
+  const link = join(reflexioDir, "plugin-root");
+  mkdirSync(reflexioDir, { recursive: true });
+  rmSync(link, { recursive: true, force: true });
+  try {
+    require("fs").symlinkSync(pluginRoot, link, "junction");
+  } catch {
+    writeFileSync(join(reflexioDir, "plugin-root.txt"), `${pluginRoot}\n`);
+  }
+}
+
+async function bootstrapWindowsCodexCache(pluginRoot) {
+  if (!isWindows()) return;
+  process.stdout.write("Preparing Windows Codex runtime for claude-smart hooks...\n");
+  const nodeRuntime = await ensureWindowsPrivateNode();
+  patchCodexHooksForWindows(pluginRoot, nodeRuntime.node);
+  ensureWindowsPluginRoot(pluginRoot);
+  const uv = await ensureWindowsUv();
+  const env = runtimeEnv([dirname(uv), ...privateNodeBinDirs()]);
+  let code = await runChecked(
+    uv,
+    ["sync", "--locked", "--python", "3.12", "--quiet"],
+    { cwd: pluginRoot, env },
+  );
+  if (code !== 0) throw new Error(`uv sync failed in ${pluginRoot}`);
+
+  const dashboardDir = join(pluginRoot, "dashboard");
+  if (existsSync(dashboardDir)) {
+    code = await runChecked(nodeRuntime.npm, ["ci"], { cwd: dashboardDir, env });
+    if (code !== 0) throw new Error(`npm ci failed in ${dashboardDir}`);
+    code = await runChecked(nodeRuntime.npm, ["run", "build"], { cwd: dashboardDir, env });
+    if (code !== 0) throw new Error(`npm run build failed in ${dashboardDir}`);
+  }
+}
+
 function printHelp() {
   process.stdout.write(
     [
@@ -205,9 +452,10 @@ function printHelp() {
       "Codex install:",
       `  1. Copies the bundled marketplace to ${CODEX_MARKETPLACE_DIR}`,
       "  2. codex plugin marketplace add <copied marketplace>",
-      "  3. codex features enable plugin_hooks",
+      "  3. codex features enable hooks && codex features enable plugin_hooks",
       "  4. Installs claude-smart into Codex's plugin cache and enables it",
-      "  5. Restart Codex.",
+      "  5. Trusts and enables claude-smart hook entries in ~/.codex/config.toml",
+      "  6. Restart Codex.",
       "",
       "Update:",
       "  npx claude-smart update                        Update to the latest version",
@@ -359,6 +607,227 @@ function setCodexPluginEnabled() {
   writeFileSync(CODEX_CONFIG_PATH, next);
 }
 
+function tomlDottedQuoted(name) {
+  return `"${name.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function setTomlFeature(feature, value) {
+  // Minimal port of `_set_toml_feature` in plugin/src/claude_smart/cli.py:
+  // ensures `[features]\n<feature> = <bool>\n` is present in
+  // ~/.codex/config.toml, replacing any prior value for the same key.
+  const desired = `${feature} = ${value ? "true" : "false"}`;
+  const sectionRe = /^\s*\[([^\]]+)\]\s*(?:#.*)?$/;
+  const featureRe = new RegExp(`^\\s*${feature.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*=`);
+  const text = existsSync(CODEX_CONFIG_PATH)
+    ? readFileSync(CODEX_CONFIG_PATH, "utf8")
+    : "";
+  const lines = text.split("\n");
+  let inFeatures = false;
+  let featuresIdx = null;
+  let insertIdx = null;
+  let changed = false;
+  const out = [];
+  for (const line of lines) {
+    const sectionMatch = line.match(sectionRe);
+    if (sectionMatch) {
+      if (inFeatures && insertIdx === null) insertIdx = out.length;
+      inFeatures = sectionMatch[1].trim() === "features";
+      if (inFeatures) featuresIdx = out.length;
+      out.push(line);
+      continue;
+    }
+    if (inFeatures && featureRe.test(line)) {
+      out.push(desired);
+      changed = changed || line !== desired;
+      continue;
+    }
+    out.push(line);
+  }
+  if (featuresIdx === null) {
+    if (out.length && out[out.length - 1].trim()) out.push("");
+    out.push("[features]", desired);
+    changed = true;
+  } else {
+    const sectionEnd = insertIdx !== null ? insertIdx : out.length;
+    let hasFeature = false;
+    for (let i = featuresIdx + 1; i < sectionEnd; i++) {
+      if (featureRe.test(out[i])) { hasFeature = true; break; }
+    }
+    if (!hasFeature) {
+      const idx = insertIdx !== null ? insertIdx : out.length;
+      out.splice(idx, 0, desired);
+      changed = true;
+    }
+  }
+  if (!changed && text.endsWith("\n")) return true;
+  mkdirSync(dirname(CODEX_CONFIG_PATH), { recursive: true });
+  let payload = out.join("\n");
+  if (!payload.endsWith("\n")) payload += "\n";
+  writeFileSync(CODEX_CONFIG_PATH, payload);
+  return true;
+}
+
+function setCodexHookStates(states) {
+  const entries = Object.entries(states);
+  if (entries.length === 0) return false;
+  removeTomlSections(CODEX_CONFIG_PATH, {
+    exact: new Set(),
+    prefixes: [`hooks.state."${CODEX_PLUGIN_ID}:`],
+  });
+  const existing = existsSync(CODEX_CONFIG_PATH)
+    ? readFileSync(CODEX_CONFIG_PATH, "utf8")
+    : "";
+  let next = existing;
+  if (next && !next.endsWith("\n")) next += "\n";
+  if (!next.includes("[hooks.state]")) {
+    if (next.trim()) next += "\n";
+    next += "[hooks.state]\n";
+  }
+  if (next.trim()) next += "\n";
+  for (const [key, currentHash] of entries.sort(([a], [b]) => a.localeCompare(b))) {
+    next += `[hooks.state.${tomlDottedQuoted(key)}]\n`;
+    next += "enabled = true\n";
+    next += `trusted_hash = "${currentHash}"\n\n`;
+  }
+  mkdirSync(dirname(CODEX_CONFIG_PATH), { recursive: true });
+  writeFileSync(CODEX_CONFIG_PATH, next.trimEnd() + "\n");
+  return true;
+}
+
+function createCodexAppServerClient(child) {
+  // A single long-lived stdout listener that demultiplexes JSON-RPC responses
+  // by id. Avoids losing messages between sequential requests.
+  const pending = new Map();
+  let buffer = "";
+  let exited = false;
+
+  const onData = (chunk) => {
+    buffer += chunk.toString();
+    let newline;
+    while ((newline = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (!line.trim()) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const entry = pending.get(message.id);
+      if (!entry) continue;
+      pending.delete(message.id);
+      clearTimeout(entry.timer);
+      if (message.error) {
+        entry.reject(new Error(JSON.stringify(message.error)));
+      } else {
+        entry.resolve(message);
+      }
+    }
+  };
+  const onExit = () => {
+    exited = true;
+    for (const entry of pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("Codex app-server exited before responding"));
+    }
+    pending.clear();
+  };
+  child.stdout.on("data", onData);
+  child.on("exit", onExit);
+
+  return {
+    request(id, method, params, timeoutMs) {
+      return new Promise((resolve, reject) => {
+        if (exited) {
+          reject(new Error("Codex app-server exited before responding"));
+          return;
+        }
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`Codex app-server ${method} timed out`));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        child.stdin.write(JSON.stringify({ id, method, params }) + "\n");
+      });
+    },
+    notify(method, params) {
+      if (exited) return;
+      child.stdin.write(JSON.stringify({ method, params }) + "\n");
+    },
+    close() {
+      child.stdout.off("data", onData);
+      child.off("exit", onExit);
+    },
+  };
+}
+
+async function listCodexPluginHooks(cwd) {
+  const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
+    stdio: ["pipe", "pipe", "ignore"],
+  });
+  const client = createCodexAppServerClient(child);
+  try {
+    await client.request(
+      1,
+      "initialize",
+      {
+        clientInfo: {
+          name: "claude_smart_installer",
+          title: "claude-smart installer",
+          version: "0.0.0",
+        },
+        capabilities: { experimentalApi: true },
+      },
+      CODEX_CLI_TIMEOUT_MS,
+    );
+    client.notify("initialized", {});
+    const response = await client.request(
+      2,
+      "hooks/list",
+      { cwds: [cwd] },
+      CODEX_CLI_TIMEOUT_MS,
+    );
+    const hooks = response.result?.data?.[0]?.hooks;
+    if (!Array.isArray(hooks)) {
+      throw new Error("Codex app-server hook metadata was malformed");
+    }
+    return hooks.filter(
+      (hook) =>
+        hook &&
+        (hook.pluginId === CODEX_PLUGIN_ID ||
+          String(hook.key || "").startsWith(`${CODEX_PLUGIN_ID}:`)),
+    );
+  } finally {
+    client.close();
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.kill("SIGTERM");
+    child.unref();
+  }
+}
+
+async function trustCodexPluginHooks(cwd) {
+  const hooks = await listCodexPluginHooks(cwd);
+  const states = {};
+  for (const hook of hooks) {
+    if (
+      typeof hook.key === "string" &&
+      hook.key.startsWith(`${CODEX_PLUGIN_ID}:`) &&
+      typeof hook.currentHash === "string"
+    ) {
+      states[hook.key] = hook.currentHash;
+    }
+  }
+  if (Object.keys(states).length === 0) {
+    throw new Error("Codex did not report trust hashes for claude-smart hooks");
+  }
+  if (!setCodexHookStates(states)) {
+    throw new Error(`could not write claude-smart hook trust state to ${CODEX_CONFIG_PATH}`);
+  }
+  return Object.keys(states).length;
+}
+
 function codexPluginVersion(pluginRoot) {
   try {
     const manifest = JSON.parse(
@@ -515,24 +984,60 @@ async function runInstallCodex() {
     process.exit(code);
   }
 
-  code = await runCodex(["features", "enable", "plugin_hooks"]);
-  if (code !== 0) {
-    process.stderr.write("error: could not enable Codex plugin_hooks feature.\n");
-    process.exit(code);
+  for (const feature of ["hooks", "plugin_hooks"]) {
+    code = await runCodex(["features", "enable", feature]);
+    if (code !== 0) {
+      // Older Codex builds may not recognize the `hooks` feature name; fall
+      // through to writing the flag directly under [features] in config.toml.
+      try {
+        setTomlFeature(feature, true);
+        process.stdout.write(`Enabled Codex ${feature} via ${CODEX_CONFIG_PATH}.\n`);
+      } catch (err) {
+        process.stderr.write(
+          `error: could not enable Codex ${feature} feature: ${err && err.message ? err.message : err}\n`,
+        );
+        process.exit(code);
+      }
+    }
   }
 
   let cacheDir = null;
+  let trustedHookCount = 0;
+  let trustError = null;
   try {
     cacheDir = installCodexPluginCache(join(marketplaceRoot, CODEX_MARKETPLACE_PLUGIN_PATH));
     process.stdout.write(`Installed Codex plugin cache at ${cacheDir}.\n`);
+    await bootstrapWindowsCodexCache(cacheDir);
   } catch (err) {
     process.stderr.write(
       `error: automatic Codex plugin install failed: ${err && err.message ? err.message : err}\n`,
     );
     process.stderr.write(
-      `Open Codex, run /plugins, and install claude-smart from the ${CODEX_MARKETPLACE_DISPLAY_NAME} marketplace manually.\n`,
+      `Open Codex, run /plugins, install claude-smart from the ${CODEX_MARKETPLACE_DISPLAY_NAME} marketplace, and restart Codex.\n`,
+    );
+    process.exit(1);
+  }
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      trustedHookCount = await trustCodexPluginHooks(process.cwd());
+      trustError = null;
+      break;
+    } catch (err) {
+      trustError = err;
+      if (attempt === 0) await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  if (trustError) {
+    process.stderr.write(
+      `warning: ${trustError && trustError.message ? trustError.message : trustError}\n`,
+    );
+    process.stderr.write(
+      `Fully quit and reopen Codex in this repo, run /hooks, trust the claude-smart hooks, and restart Codex.\n`,
     );
     process.exit(1);
+  } else {
+    process.stdout.write(`Trusted and enabled ${trustedHookCount} claude-smart Codex hooks.\n`);
   }
 
   const added = seedReflexioEnv();
@@ -544,7 +1049,7 @@ async function runInstallCodex() {
     [
       "",
       "claude-smart Codex support is installed.",
-      `Restart Codex so the installed plugin and hooks reload. /plugins should show claude-smart as installed from the ${CODEX_MARKETPLACE_DISPLAY_NAME} marketplace.`,
+      `Restart Codex so the installed plugin and trusted hooks reload. /plugins should show claude-smart as installed from the ${CODEX_MARKETPLACE_DISPLAY_NAME} marketplace.`,
       "Local data is shared with Claude Code under ~/.reflexio/ and ~/.claude-smart/.",
       "",
     ].join("\n"),
@@ -570,7 +1075,7 @@ async function runUninstallCodex() {
     [
       "",
       "claude-smart Codex plugin and marketplace state removed. Restart Codex to apply.",
-      "Codex's global plugin_hooks feature and local data under ~/.reflexio/ and ~/.claude-smart/ were left in place.",
+      "Codex's global hook feature flags and local data under ~/.reflexio/ and ~/.claude-smart/ were left in place.",
       "",
     ].join("\n"),
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Self-improving Claude Code plugin — learns from corrections via reflexio",
   "keywords": [
     "claude",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Self-improving Claude Code plugin — learns from corrections across sessions via reflexio",
   "author": {
     "name": "Yi Lu"

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smart",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Self-improving coding assistant plugin — learns from corrections across sessions via reflexio",
   "author": {
     "name": "Yi Lu"
@@ -17,6 +17,7 @@
     "playbook",
     "learning"
   ],
+  "skills": "./skills/",
   "hooks": "./hooks/codex-hooks.json",
   "interface": {
     "displayName": "claude-smart",