claude-smart 0.2.45 → 0.2.46

package/plugin/opencode/dist/internal.js

@@ -0,0 +1,12 @@
+export function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function eventProperties(event) {
+    return isRecord(event.properties) ? event.properties : event;
+}
+export function sessionIDFrom(value) {
+    if (!isRecord(value))
+        return "";
+    const raw = value.sessionID ?? value.session_id;
+    return typeof raw === "string" ? raw : "";
+}

package/plugin/opencode/dist/payload.js

@@ -0,0 +1,85 @@
+import { eventProperties, isRecord, sessionIDFrom } from "./internal.js";
+function textFromParts(parts) {
+    if (!Array.isArray(parts))
+        return "";
+    return parts
+        .map((part) => (part && part.type === "text" && typeof part.text === "string" ? part.text : ""))
+        .filter(Boolean)
+        .join("\n\n");
+}
+export function eventPayload(event, cwd) {
+    const properties = eventProperties(event);
+    const info = isRecord(properties.info) ? properties.info : {};
+    return {
+        session_id: sessionIDFrom(properties) || sessionIDFrom(info),
+        cwd: typeof info.directory === "string" ? info.directory : cwd,
+    };
+}
+export function chatMessagePayload(input, output, cwd) {
+    const message = isRecord(output.message) ? output.message : {};
+    const prompt = textFromParts(output.parts) ||
+        (typeof message.content === "string" ? message.content : "") ||
+        textFromParts(message.parts);
+    return {
+        session_id: sessionIDFrom(input),
+        cwd,
+        prompt,
+    };
+}
+export function normalizeToolName(tool) {
+    const lowered = tool.toLowerCase();
+    if (lowered === "edit")
+        return "Edit";
+    if (lowered === "write")
+        return "Write";
+    if (lowered === "apply_patch")
+        return "apply_patch";
+    if (["bash", "shell", "terminal", "exec", "command"].includes(lowered))
+        return "Bash";
+    return tool;
+}
+export function normalizeToolInput(tool, args) {
+    if (!isRecord(args))
+        return {};
+    const out = { ...args };
+    const copy = (from, to) => {
+        if (from in args && !(to in out))
+            out[to] = args[from];
+    };
+    copy("filePath", "file_path");
+    copy("oldString", "old_string");
+    copy("newString", "new_string");
+    copy("patchText", "command");
+    if (normalizeToolName(tool) === "Bash") {
+        copy("cmd", "command");
+        copy("script", "command");
+    }
+    return out;
+}
+export function toolAfterPayload(input, output, cwd) {
+    const tool = typeof input.tool === "string" ? input.tool : "";
+    const text = typeof output.output === "string" ? output.output : "";
+    const response = {
+        output: text,
+        stdout: text,
+    };
+    if (typeof output.title === "string")
+        response.title = output.title;
+    if (isRecord(output.metadata))
+        response.metadata = output.metadata;
+    if (isRecord(output.metadata) && output.metadata.error)
+        response.error = output.metadata.error;
+    return {
+        session_id: sessionIDFrom(input),
+        cwd,
+        tool_name: normalizeToolName(tool),
+        tool_input: normalizeToolInput(tool, input.args),
+        tool_response: response,
+    };
+}
+export function stopPayload(event, cwd, lastAssistantMessage) {
+    return {
+        ...eventPayload(event, cwd),
+        last_assistant_message: lastAssistantMessage,
+    };
+}

package/plugin/opencode/dist/server.mjs

@@ -0,0 +1,158 @@
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AssistantBuffer } from "./assistant-buffer.js";
+import { sessionIDFrom } from "./internal.js";
+import { chatMessagePayload, eventPayload, stopPayload, toolAfterPayload } from "./payload.js";
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = resolve(MODULE_DIR, "../..");
+const SCRIPTS_DIR = resolve(PLUGIN_ROOT, "scripts");
+const HOOK_ENTRY = resolve(SCRIPTS_DIR, "hook_entry.sh");
+const BACKEND_SERVICE = resolve(SCRIPTS_DIR, "backend-service.sh");
+const DASHBOARD_SERVICE = resolve(SCRIPTS_DIR, "dashboard-service.sh");
+function contextFrom(result) {
+    const hookOutput = result.hookSpecificOutput;
+    if (!hookOutput || typeof hookOutput !== "object")
+        return "";
+    const additional = hookOutput.additionalContext;
+    return typeof additional === "string" ? additional : "";
+}
+function parseFirstJsonObject(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === "object")
+                return parsed;
+        }
+        catch {
+            continue;
+        }
+    }
+    return {};
+}
+function runScript(script, args, payload) {
+    return new Promise((resolvePromise) => {
+        const child = spawn("bash", [script, ...args], {
+            cwd: PLUGIN_ROOT,
+            env: {
+                ...process.env,
+                CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT,
+                CLAUDE_SMART_HOST: "opencode",
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            process.stderr.write(chunk);
+        });
+        child.stdin.on("error", () => {
+            // Hooks can exit before reading stdin on marker-gated setup failures.
+        });
+        child.on("error", () => resolvePromise({}));
+        child.on("close", () => resolvePromise(parseFirstJsonObject(stdout)));
+        try {
+            if (payload)
+                child.stdin.write(JSON.stringify(payload));
+            child.stdin.end();
+        }
+        catch {
+            resolvePromise({});
+        }
+    });
+}
+function runService(script, subcommand) {
+    return runScript(script, [subcommand]).then(() => undefined);
+}
+function cacheContext(cache, sessionID, result) {
+    const context = contextFrom(result);
+    if (!sessionID || !context)
+        return;
+    const pending = cache.get(sessionID) ?? [];
+    pending.push(context);
+    cache.set(sessionID, pending);
+}
+async function server(input) {
+    const pendingContext = new Map();
+    const activeSessions = new Set();
+    const completedAssistantText = new Map();
+    const assistant = new AssistantBuffer();
+    const cwd = input.directory;
+    async function flushStop(sessionID) {
+        if (!sessionID || !activeSessions.has(sessionID))
+            return;
+        activeSessions.delete(sessionID);
+        const text = assistant.text(sessionID) || completedAssistantText.get(sessionID) || "";
+        completedAssistantText.delete(sessionID);
+        await runScript(HOOK_ENTRY, ["opencode", "stop"], stopPayload({ properties: { sessionID, info: { directory: cwd } } }, cwd, text));
+        assistant.clear(sessionID);
+    }
+    return {
+        event: async ({ event }) => {
+            const type = event.type;
+            assistant.update(event);
+            if (type === "session.created") {
+                const payload = eventPayload(event, cwd);
+                const sessionID = String(payload.session_id || "");
+                if (!sessionID)
+                    return;
+                activeSessions.add(sessionID);
+                await runService(BACKEND_SERVICE, "start");
+                await runService(DASHBOARD_SERVICE, "start");
+                const result = await runScript(HOOK_ENTRY, ["opencode", "session-start"], payload);
+                cacheContext(pendingContext, sessionID, result);
+                return;
+            }
+            if (type === "session.idle") {
+                const payload = eventPayload(event, cwd);
+                const sessionID = String(payload.session_id || "");
+                if (!sessionID)
+                    return;
+                await flushStop(sessionID);
+            }
+        },
+        "chat.message": async (hookInput, output) => {
+            const payload = chatMessagePayload(hookInput, output, cwd);
+            if (!payload.session_id || !payload.prompt)
+                return;
+            activeSessions.add(String(payload.session_id || ""));
+            const result = await runScript(HOOK_ENTRY, ["opencode", "user-prompt"], payload);
+            cacheContext(pendingContext, String(payload.session_id || ""), result);
+        },
+        "experimental.chat.system.transform": async (hookInput, output) => {
+            const sessionID = sessionIDFrom(hookInput);
+            const pending = pendingContext.get(sessionID);
+            if (!pending?.length)
+                return;
+            output.system.push(...pending);
+            pendingContext.delete(sessionID);
+        },
+        "tool.execute.after": async (hookInput, output) => {
+            const payload = toolAfterPayload(hookInput, output, cwd);
+            if (!payload.session_id || !payload.tool_name)
+                return;
+            await runScript(HOOK_ENTRY, ["opencode", "post-tool"], payload);
+        },
+        "experimental.text.complete": async (hookInput, output) => {
+            const sessionID = typeof hookInput.sessionID === "string" ? hookInput.sessionID : "";
+            if (!sessionID)
+                return;
+            if (typeof output.text === "string")
+                completedAssistantText.set(sessionID, output.text);
+        },
+        dispose: async () => {
+            await Promise.all([...activeSessions].map((sessionID) => flushStop(sessionID)));
+            await runService(DASHBOARD_SERVICE, "session-end");
+            await runService(BACKEND_SERVICE, "session-end");
+        },
+    };
+}
+export default {
+    id: "claude-smart",
+    server,
+};

package/plugin/opencode/internal.ts

@@ -0,0 +1,18 @@
+export type EventLike = {
+  type?: string
+  properties?: Record<string, unknown>
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value)
+}
+
+export function eventProperties(event: EventLike): Record<string, unknown> {
+  return isRecord(event.properties) ? event.properties : (event as Record<string, unknown>)
+}
+
+export function sessionIDFrom(value: unknown): string {
+  if (!isRecord(value)) return ""
+  const raw = value.sessionID ?? value.session_id
+  return typeof raw === "string" ? raw : ""
+}

package/plugin/opencode/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/plugin/opencode/payload.ts

@@ -0,0 +1,90 @@
+import { eventProperties, type EventLike, isRecord, sessionIDFrom } from "./internal.js"
+
+type PartLike = {
+  type?: string
+  text?: string
+}
+
+export type PythonPayload = Record<string, unknown>
+
+function textFromParts(parts: unknown): string {
+  if (!Array.isArray(parts)) return ""
+  return parts
+    .map((part: PartLike) => (part && part.type === "text" && typeof part.text === "string" ? part.text : ""))
+    .filter(Boolean)
+    .join("\n\n")
+}
+
+export function eventPayload(event: EventLike, cwd: string): PythonPayload {
+  const properties = eventProperties(event)
+  const info = isRecord(properties.info) ? properties.info : {}
+  return {
+    session_id: sessionIDFrom(properties) || sessionIDFrom(info),
+    cwd: typeof info.directory === "string" ? info.directory : cwd,
+  }
+}
+
+export function chatMessagePayload(input: Record<string, unknown>, output: Record<string, unknown>, cwd: string): PythonPayload {
+  const message = isRecord(output.message) ? output.message : {}
+  const prompt =
+    textFromParts(output.parts) ||
+    (typeof message.content === "string" ? message.content : "") ||
+    textFromParts(message.parts)
+  return {
+    session_id: sessionIDFrom(input),
+    cwd,
+    prompt,
+  }
+}
+
+export function normalizeToolName(tool: string): string {
+  const lowered = tool.toLowerCase()
+  if (lowered === "edit") return "Edit"
+  if (lowered === "write") return "Write"
+  if (lowered === "apply_patch") return "apply_patch"
+  if (["bash", "shell", "terminal", "exec", "command"].includes(lowered)) return "Bash"
+  return tool
+}
+
+export function normalizeToolInput(tool: string, args: unknown): Record<string, unknown> {
+  if (!isRecord(args)) return {}
+  const out: Record<string, unknown> = { ...args }
+  const copy = (from: string, to: string) => {
+    if (from in args && !(to in out)) out[to] = args[from]
+  }
+  copy("filePath", "file_path")
+  copy("oldString", "old_string")
+  copy("newString", "new_string")
+  copy("patchText", "command")
+  if (normalizeToolName(tool) === "Bash") {
+    copy("cmd", "command")
+    copy("script", "command")
+  }
+  return out
+}
+
+export function toolAfterPayload(input: Record<string, unknown>, output: Record<string, unknown>, cwd: string): PythonPayload {
+  const tool = typeof input.tool === "string" ? input.tool : ""
+  const text = typeof output.output === "string" ? output.output : ""
+  const response: Record<string, unknown> = {
+    output: text,
+    stdout: text,
+  }
+  if (typeof output.title === "string") response.title = output.title
+  if (isRecord(output.metadata)) response.metadata = output.metadata
+  if (isRecord(output.metadata) && output.metadata.error) response.error = output.metadata.error
+  return {
+    session_id: sessionIDFrom(input),
+    cwd,
+    tool_name: normalizeToolName(tool),
+    tool_input: normalizeToolInput(tool, input.args),
+    tool_response: response,
+  }
+}
+
+export function stopPayload(event: EventLike, cwd: string, lastAssistantMessage: string): PythonPayload {
+  return {
+    ...eventPayload(event, cwd),
+    last_assistant_message: lastAssistantMessage,
+  }
+}

package/plugin/opencode/server.mts

@@ -0,0 +1,174 @@
+import { spawn } from "node:child_process"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+import { AssistantBuffer } from "./assistant-buffer.js"
+import { sessionIDFrom } from "./internal.js"
+import { chatMessagePayload, eventPayload, stopPayload, toolAfterPayload } from "./payload.js"
+
+type HookResult = Record<string, unknown>
+
+type PluginInput = {
+  directory: string
+}
+
+type EventInput = {
+  event: {
+    type?: string
+    properties?: Record<string, unknown>
+  }
+}
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url))
+const PLUGIN_ROOT = resolve(MODULE_DIR, "../..")
+const SCRIPTS_DIR = resolve(PLUGIN_ROOT, "scripts")
+const HOOK_ENTRY = resolve(SCRIPTS_DIR, "hook_entry.sh")
+const BACKEND_SERVICE = resolve(SCRIPTS_DIR, "backend-service.sh")
+const DASHBOARD_SERVICE = resolve(SCRIPTS_DIR, "dashboard-service.sh")
+
+function contextFrom(result: HookResult): string {
+  const hookOutput = result.hookSpecificOutput
+  if (!hookOutput || typeof hookOutput !== "object") return ""
+  const additional = (hookOutput as Record<string, unknown>).additionalContext
+  return typeof additional === "string" ? additional : ""
+}
+
+function parseFirstJsonObject(text: string): HookResult {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed.startsWith("{")) continue
+    try {
+      const parsed = JSON.parse(trimmed)
+      if (parsed && typeof parsed === "object") return parsed as HookResult
+    } catch {
+      continue
+    }
+  }
+  return {}
+}
+
+function runScript(script: string, args: string[], payload?: Record<string, unknown>): Promise<HookResult> {
+  return new Promise((resolvePromise) => {
+    const child = spawn("bash", [script, ...args], {
+      cwd: PLUGIN_ROOT,
+      env: {
+        ...process.env,
+        CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT,
+        CLAUDE_SMART_HOST: "opencode",
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+    let stdout = ""
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString()
+    })
+    child.stderr.on("data", (chunk) => {
+      process.stderr.write(chunk)
+    })
+    child.stdin.on("error", () => {
+      // Hooks can exit before reading stdin on marker-gated setup failures.
+    })
+    child.on("error", () => resolvePromise({}))
+    child.on("close", () => resolvePromise(parseFirstJsonObject(stdout)))
+    try {
+      if (payload) child.stdin.write(JSON.stringify(payload))
+      child.stdin.end()
+    } catch {
+      resolvePromise({})
+    }
+  })
+}
+
+function runService(script: string, subcommand: string): Promise<void> {
+  return runScript(script, [subcommand]).then(() => undefined)
+}
+
+function cacheContext(cache: Map<string, string[]>, sessionID: string, result: HookResult): void {
+  const context = contextFrom(result)
+  if (!sessionID || !context) return
+  const pending = cache.get(sessionID) ?? []
+  pending.push(context)
+  cache.set(sessionID, pending)
+}
+
+async function server(input: PluginInput) {
+  const pendingContext = new Map<string, string[]>()
+  const activeSessions = new Set<string>()
+  const completedAssistantText = new Map<string, string>()
+  const assistant = new AssistantBuffer()
+  const cwd = input.directory
+
+  async function flushStop(sessionID: string): Promise<void> {
+    if (!sessionID || !activeSessions.has(sessionID)) return
+    activeSessions.delete(sessionID)
+    const text = assistant.text(sessionID) || completedAssistantText.get(sessionID) || ""
+    completedAssistantText.delete(sessionID)
+    await runScript(
+      HOOK_ENTRY,
+      ["opencode", "stop"],
+      stopPayload({ properties: { sessionID, info: { directory: cwd } } }, cwd, text),
+    )
+    assistant.clear(sessionID)
+  }
+
+  return {
+    event: async ({ event }: EventInput) => {
+      const type = event.type
+      assistant.update(event)
+      if (type === "session.created") {
+        const payload = eventPayload(event, cwd)
+        const sessionID = String(payload.session_id || "")
+        if (!sessionID) return
+        activeSessions.add(sessionID)
+        await runService(BACKEND_SERVICE, "start")
+        await runService(DASHBOARD_SERVICE, "start")
+        const result = await runScript(HOOK_ENTRY, ["opencode", "session-start"], payload)
+        cacheContext(pendingContext, sessionID, result)
+        return
+      }
+      if (type === "session.idle") {
+        const payload = eventPayload(event, cwd)
+        const sessionID = String(payload.session_id || "")
+        if (!sessionID) return
+        await flushStop(sessionID)
+      }
+    },
+    "chat.message": async (hookInput: Record<string, unknown>, output: Record<string, unknown>) => {
+      const payload = chatMessagePayload(hookInput, output, cwd)
+      if (!payload.session_id || !payload.prompt) return
+      activeSessions.add(String(payload.session_id || ""))
+      const result = await runScript(HOOK_ENTRY, ["opencode", "user-prompt"], payload)
+      cacheContext(pendingContext, String(payload.session_id || ""), result)
+    },
+    "experimental.chat.system.transform": async (hookInput: Record<string, unknown>, output: { system: string[] }) => {
+      const sessionID = sessionIDFrom(hookInput)
+      const pending = pendingContext.get(sessionID)
+      if (!pending?.length) return
+      output.system.push(...pending)
+      pendingContext.delete(sessionID)
+    },
+    "tool.execute.after": async (hookInput: Record<string, unknown>, output: Record<string, unknown>) => {
+      const payload = toolAfterPayload(hookInput, output, cwd)
+      if (!payload.session_id || !payload.tool_name) return
+      await runScript(HOOK_ENTRY, ["opencode", "post-tool"], payload)
+    },
+    "experimental.text.complete": async (
+      hookInput: { sessionID?: string },
+      output: { text?: string },
+    ) => {
+      const sessionID = typeof hookInput.sessionID === "string" ? hookInput.sessionID : ""
+      if (!sessionID) return
+      if (typeof output.text === "string") completedAssistantText.set(sessionID, output.text)
+    },
+    dispose: async () => {
+      await Promise.all([...activeSessions].map((sessionID) => flushStop(sessionID)))
+      await runService(DASHBOARD_SERVICE, "session-end")
+      await runService(BACKEND_SERVICE, "session-end")
+    },
+  }
+}
+
+export default {
+  id: "claude-smart",
+  server,
+}

package/plugin/opencode/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": ".",
+    "outDir": "dist"
+  },
+  "include": ["*.ts", "*.mts"]
+}

package/plugin/pyproject.toml

@@ -1,7 +1,24 @@
 [project]
 name = "claude-smart"
-version = "0.2.45"
-description = "Self-improving Claude Code and Codex plugin that turns corrections into Preferences, Project-specific skills, and Shared skills"
+version = "0.2.46"
+description = "Self-improving Claude Code, Codex, and OpenCode plugin that turns corrections into Preferences, Project-specific skills, and Shared skills"
+keywords = [
+    "claude",
+    "claude-code",
+    "claude-code-plugin",
+    "codex",
+    "codex-plugin",
+    "opencode",
+    "opencode-plugin",
+    "memory",
+    "agent-memory",
+    "plugin",
+    "reflexio",
+    "self-improvement",
+    "self-improving-agents",
+    "skills",
+    "learning",
+]
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
@@ -9,7 +26,7 @@ dependencies = [
     # normal installs; vendor releases may override it after uv sync by
     # installing plugin/vendor/reflexio. Keep in sync via
     # scripts/sync-reflexio-dep.py.
-    "reflexio-ai>=0.2.25",
+    "reflexio-ai>=0.2.27",
     # Needed when Reflexio runs the local embedding provider (ONNXMiniLM_L6_V2).
     # Pulls in onnxruntime + tokenizers; the ~80 MB ONNX model itself is
     # downloaded on first use, not at install time.

package/plugin/scripts/_lib.sh

@@ -87,8 +87,12 @@ claude_smart_env_unquote() {
 }
 
 claude_smart_source_reflexio_env() {
+  # claude-smart's env lives at ~/.claude-smart/.env (kept separate from the OSS
+  # reflexio default ~/.reflexio/.env). Stays in sync with
+  # env_config.REFLEXIO_ENV_PATH and the REFLEXIO_ENV_FILE export in
+  # backend-service.sh.
   local env_file line key value
-  env_file="$HOME/.reflexio/.env"
+  env_file="$HOME/.claude-smart/.env"
   [ -f "$env_file" ] || return 0
   while IFS= read -r line || [ -n "$line" ]; do
     line="${line#"${line%%[![:space:]]*}"}"

package/plugin/scripts/backend-service.sh

@@ -34,6 +34,21 @@ EMBEDDING_PORT="${EMBEDDING_PORT:-8072}"
 export BACKEND_PORT="$PORT"
 export EMBEDDING_PORT
 
+# Run claude-smart's backend under its own org id. The reflexio no-auth resolver
+# reads REFLEXIO_DEFAULT_ORG_ID, which scopes the request org -> config file
+# name (config_<org>.json) and SQLite data. Hard-set (not :-defaulted) so a
+# value in the shared ~/.reflexio/.env can't drag claude-smart back onto
+# "self-host-org" and collide with the enterprise self-host backend over
+# config_self-host-org.json. Must stay in sync with cli.py's config path.
+export REFLEXIO_DEFAULT_ORG_ID="claude-smart"
+
+# Load claude-smart's env from ~/.claude-smart/.env instead of the reflexio
+# default ~/.reflexio/.env, so an OSS reflexio backend's .env on this machine
+# can't leak in. The data dir is independent (LOCAL_STORAGE_PATH), so both still
+# share ~/.reflexio/data. Must stay in sync with env_config.REFLEXIO_ENV_PATH and
+# the source path in _lib.sh (claude_smart_source_reflexio_env).
+export REFLEXIO_ENV_FILE="$HOME/.claude-smart/.env"
+
 # Default: route extraction through the active host CLI + ONNX embedder
 # so claude-smart works without any LLM API key. Users can opt out by
 # pre-exporting these to 0.
@@ -50,7 +65,12 @@ PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "backend-service.sh" "$@"
 
 if [ -z "${CLAUDE_SMART_CLI_PATH:-}" ]; then
-  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "codex" ]; then
+  if [ "${CLAUDE_SMART_HOST:-claude-code}" = "opencode" ] && command -v opencode >/dev/null 2>&1; then
+    # Preserve Reflexio's Claude CLI provider contract while routing
+    # generation through the user's authenticated OpenCode setup.
+    claude_smart_prepend_node_bins
+    export CLAUDE_SMART_CLI_PATH="$PLUGIN_ROOT/scripts/opencode-claude-compat"
+  elif [ "${CLAUDE_SMART_HOST:-claude-code}" = "codex" ]; then
     # Reflexio's provider still calls CLAUDE_SMART_CLI_PATH with Claude CLI
     # flags. Use a small compatibility executable that translates that narrow
     # contract to `codex exec`.
@@ -286,7 +306,7 @@ case "$CMD" in
     # Keep plugin runtime data in ~/.reflexio even when the backend imports
     # Reflexio from an editable checkout inside a larger repo with its own
     # .env. python-dotenv respects pre-existing env vars, so this prevents a
-    # parent REFLEXIO_LOG_DIR from sending claude-smart to enterprise configs.
+    # parent REFLEXIO_LOG_DIR from sending claude-smart to unrelated configs.
     export REFLEXIO_LOG_DIR="${REFLEXIO_LOG_DIR:-$HOME}"
 
     # Force sqlite: the plugin venv ships only the open-source reflexio

package/plugin/scripts/ensure-plugin-root.sh

@@ -32,12 +32,12 @@ if [ "$FORCE" = "--force" ]; then
 fi
 
 # Opt-in: when CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=1 (set in the
-# environment or in ~/.reflexio/.env), always relink to $TARGET so the
+# environment or in ~/.claude-smart/.env), always relink to $TARGET so the
 # symlink tracks the currently loaded plugin.
 FOLLOW="${CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION:-}"
-if [ -z "$FOLLOW" ] && [ -f "$HOME/.reflexio/.env" ]; then
-    FOLLOW="$(grep -E '^CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.reflexio/.env" \
-        | tail -n1 | cut -d= -f2-)"
+if [ -z "$FOLLOW" ] && [ -f "$HOME/.claude-smart/.env" ]; then
+    FOLLOW="$(grep -E '^(export[[:space:]]+)?CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=' "$HOME/.claude-smart/.env" \
+        | tail -n1 | sed -E 's/^(export[[:space:]]+)?CLAUDE_SMART_PLUGIN_ROOT_FOLLOW_SESSION=//')"
     # Strip a single pair of surrounding double or single quotes, if present.
     FOLLOW="${FOLLOW#\"}"; FOLLOW="${FOLLOW%\"}"
     FOLLOW="${FOLLOW#\'}"; FOLLOW="${FOLLOW%\'}"