@love-moon/ai-sdk 0.7.4 → 0.7.6

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @love-moon/ai-sdk
 
+## 0.7.6
+
+### Patch Changes
+
+- 7bbb412: Add `CONDUCTOR_HOME` support for relocating user-level configuration, logs,
+  Fire locks, sessions, update metadata, and AI manager caches while leaving
+  project-scoped `.conductor` directories and Fire task markers in place.
+
+  Migrate device authorization to `conductor.conductor-ai.top` while preserving
+  compatibility with the legacy official endpoint and self-hosted backends.
+
+## 0.7.5
+
+### Patch Changes
+
+- f91a5df: Read Codex weekly quota from the official app-server account rate-limit RPC, ignore model-specific buckets, and invalidate legacy response-header caches.
+
 ## 0.7.4
 
 ### Patch Changes

package/dist/manager/config.js

@@ -1,12 +1,12 @@
 import { readFile } from "node:fs/promises";
 import { parse as parseYaml } from "yaml";
-import { DEFAULT_CONDUCTOR_CONFIG, expandHome } from "./paths.js";
+import { expandHome, resolveDefaultConductorConfig } from "./paths.js";
 const EMPTY = { codex: { authJson: [] } };
 /**
  * Load the `ai_manager` section from a conductor config file.
  * Returns an empty config if the file does not exist or the section is missing.
  */
-export async function loadAiManagerConfig(configPath = DEFAULT_CONDUCTOR_CONFIG) {
+export async function loadAiManagerConfig(configPath = resolveDefaultConductorConfig()) {
     let raw;
     try {
         raw = await readFile(configPath, "utf8");

package/dist/manager/manager.d.ts

@@ -5,7 +5,7 @@ import { type GetCopilotQuotaOptions } from "./quota/copilot.js";
 import { type GetExternalQuotaListOptions, type GetExternalQuotaOptions } from "./quota/external.js";
 import type { AiManagerConfig, CodexAccount, CodexQuota, ClaudeQuota, ExternalQuota, ExternalQuotaList, KimiQuota, CopilotQuota, InstallStatus, NetworkStatus, SwitchResult, Tool } from "./types.js";
 export interface AiManagerOptions {
-    /** Path to conductor config.yaml. Default: ~/.conductor/config.yaml */
+    /** Path to conductor config.yaml. Default: $CONDUCTOR_HOME/config.yaml. */
     configPath?: string;
     /** Path to the active codex auth.json. Default: ~/.codex/auth.json */
     codexAuthPath?: string;
@@ -20,7 +20,7 @@ export declare class AiManager {
     constructor(opts?: AiManagerOptions);
     /**
      * Read the latest ai_manager config. Cached against the config file's mtime,
-     * so edits to ~/.conductor/config.yaml are picked up immediately without
+     * so edits to the resolved Conductor config.yaml are picked up immediately without
      * restarting the daemon, while a 30s polling cycle does not re-parse YAML
      * on every action. Falls back to always-reload if stat() fails.
      * The `config` constructor option short-circuits disk reads (used by tests).

package/dist/manager/manager.js

@@ -8,20 +8,20 @@ import { getClaudeQuota } from "./quota/claude.js";
 import { getKimiQuota } from "./quota/kimi.js";
 import { getCopilotQuota } from "./quota/copilot.js";
 import { getExternalQuota, getExternalQuotaList, } from "./quota/external.js";
-import { DEFAULT_CODEX_AUTH, DEFAULT_CONDUCTOR_CONFIG } from "./paths.js";
+import { DEFAULT_CODEX_AUTH, resolveDefaultConductorConfig } from "./paths.js";
 export class AiManager {
     configPath;
     codexAuthPath;
     configOverride;
     cached;
     constructor(opts = {}) {
-        this.configPath = opts.configPath ?? DEFAULT_CONDUCTOR_CONFIG;
+        this.configPath = opts.configPath ?? resolveDefaultConductorConfig();
         this.codexAuthPath = opts.codexAuthPath ?? DEFAULT_CODEX_AUTH;
         this.configOverride = opts.config;
     }
     /**
      * Read the latest ai_manager config. Cached against the config file's mtime,
-     * so edits to ~/.conductor/config.yaml are picked up immediately without
+     * so edits to the resolved Conductor config.yaml are picked up immediately without
      * restarting the daemon, while a 30s polling cycle does not re-parse YAML
      * on every action. Falls back to always-reload if stat() fails.
      * The `config` constructor option short-circuits disk reads (used by tests).

package/dist/manager/paths.d.ts

@@ -1,4 +1,8 @@
+type PathEnv = Record<string, string | undefined>;
 export declare function expandHome(p: string): string;
+export declare function resolveConductorHome(env?: PathEnv): string;
+export declare function resolveDefaultConductorConfig(env?: PathEnv): string;
+export declare function resolveDefaultQuotaCacheDir(env?: PathEnv): string;
 export declare const DEFAULT_CONDUCTOR_CONFIG: string;
 export declare const DEFAULT_CODEX_AUTH: string;
 export declare const DEFAULT_CODEX_CONFIG: string;
@@ -6,3 +10,4 @@ export declare const DEFAULT_KIMI_CODE_HOME: string;
 export declare const DEFAULT_KIMI_CREDENTIAL: string;
 export declare const LEGACY_KIMI_CREDENTIAL: string;
 export declare const DEFAULT_QUOTA_CACHE_DIR: string;
+export {};

package/dist/manager/paths.js

@@ -1,18 +1,46 @@
 import { homedir } from "node:os";
-import { join } from "node:path";
-export function expandHome(p) {
+import { join, resolve } from "node:path";
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function userHome(env = process.env) {
+    return optionalString(env.HOME) || optionalString(env.USERPROFILE) || homedir();
+}
+function expandHomeWithEnv(p, env = process.env) {
     if (!p)
         return p;
+    const home = userHome(env);
     if (p === "~")
-        return homedir();
-    if (p.startsWith("~/"))
-        return join(homedir(), p.slice(2));
+        return home;
+    if (p.startsWith("~/") || p.startsWith("~\\"))
+        return join(home, p.slice(2));
     return p;
 }
-export const DEFAULT_CONDUCTOR_CONFIG = join(homedir(), ".conductor", "config.yaml");
+export function expandHome(p) {
+    return expandHomeWithEnv(p);
+}
+export function resolveConductorHome(env = process.env) {
+    const configured = optionalString(env.CONDUCTOR_HOME);
+    if (configured) {
+        const expanded = expandHomeWithEnv(configured, env);
+        return resolve(expanded);
+    }
+    return join(resolve(userHome(env)), ".conductor");
+}
+export function resolveDefaultConductorConfig(env = process.env) {
+    const configured = optionalString(env.CONDUCTOR_CONFIG);
+    if (configured) {
+        return resolve(expandHomeWithEnv(configured, env));
+    }
+    return join(resolveConductorHome(env), "config.yaml");
+}
+export function resolveDefaultQuotaCacheDir(env = process.env) {
+    return join(resolveConductorHome(env), "cache", "ai-manager");
+}
+export const DEFAULT_CONDUCTOR_CONFIG = resolveDefaultConductorConfig();
 export const DEFAULT_CODEX_AUTH = join(homedir(), ".codex", "auth.json");
 export const DEFAULT_CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
 export const DEFAULT_KIMI_CODE_HOME = process.env.KIMI_CODE_HOME?.trim() || join(homedir(), ".kimi-code");
 export const DEFAULT_KIMI_CREDENTIAL = join(DEFAULT_KIMI_CODE_HOME, "credentials", "kimi-code.json");
 export const LEGACY_KIMI_CREDENTIAL = join(homedir(), ".kimi", "credentials", "kimi-code.json");
-export const DEFAULT_QUOTA_CACHE_DIR = join(homedir(), ".conductor", "cache", "ai-manager");
+export const DEFAULT_QUOTA_CACHE_DIR = resolveDefaultQuotaCacheDir();

package/dist/manager/quota/cache.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
-import { DEFAULT_QUOTA_CACHE_DIR } from "../paths.js";
+import { resolveDefaultQuotaCacheDir } from "../paths.js";
 export function fingerprintKey(parts) {
     const h = createHash("sha1");
     for (const p of parts)
@@ -23,7 +23,7 @@ export async function writeCache(file, value) {
     await writeFile(file, JSON.stringify(entry), "utf8");
     return entry;
 }
-export function cacheFile(tool, fingerprint, dir = DEFAULT_QUOTA_CACHE_DIR) {
+export function cacheFile(tool, fingerprint, dir = resolveDefaultQuotaCacheDir()) {
     return join(dir, `quota-${tool}-${fingerprint}.json`);
 }
 export function isFresh(entry, ttlSeconds) {

package/dist/manager/quota/codex.d.ts

@@ -7,25 +7,28 @@ export interface GetCodexQuotaOptions {
     forceRefresh?: boolean;
     /** Request timeout in ms. */
     timeoutMs?: number;
-    /** Model name; defaults to the one in ~/.codex/config.toml, then `gpt-5`. */
+    /** @deprecated Quota is account-scoped and no longer fetched through a model response. */
     model?: string;
-    /** Override path to codex config.toml (to detect model). */
+    /** @deprecated The Codex app-server reads its own config from CODEX_HOME. */
     codexConfigPath?: string;
     /** Override cache directory (mainly for tests). */
     cacheDir?: string;
+    /** Override the app-server reader (tests only). */
+    rateLimitsReader?: (options: {
+        codexAuthPath: string;
+        timeoutMs: number;
+    }) => Promise<unknown>;
 }
-/** Exported for protocol compatibility tests. */
-export declare function parseCodexHeaders(map: Record<string, string>, extras: {
+/** Normalize Codex app-server `account/rateLimits/read` into the manager shape. */
+export declare function parseCodexRateLimitsResponse(response: unknown, extras?: {
     email?: string;
     accountId?: string;
 }): Omit<CodexQuota, "tool" | "fetchedAt" | "source">;
 export declare function getCodexQuota(opts?: GetCodexQuotaOptions): Promise<CodexQuota>;
 /**
  * Read the on-disk quota cache for a given codex auth.json without triggering
- * any network call. Returns whatever snapshot was last written (regardless of
- * age) or `null` if nothing has been cached for this identity yet. Used by the
- * daemon's `list_accounts` handler to surface "last known" quota for inactive
- * accounts so the web UI can restore them across page refreshes.
+ * any network call. Only app-server snapshots are considered; legacy caches
+ * from response headers are intentionally ignored.
  */
 export declare function readCachedCodexQuota(codexAuthPath: string, opts?: {
     cacheDir?: string;

package/dist/manager/quota/codex.js

@@ -1,77 +1,72 @@
-import { readFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
 import { parseAuthFile } from "../auth-parser.js";
-import { DEFAULT_CODEX_AUTH, DEFAULT_CODEX_CONFIG } from "../paths.js";
-import { bool, headersToMap, num, str } from "./headers.js";
+import { DEFAULT_CODEX_AUTH } from "../paths.js";
+import { CodexAppServerTransport } from "../../transports/codex-app-server-transport.js";
 import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
-/** Best-effort: read the configured model from ~/.codex/config.toml. */
-async function readConfiguredModel(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        // Minimal top-level key scan: `model = "..."` (skip lines inside [tables]).
-        let inRootTable = true;
-        for (const line of raw.split(/\r?\n/)) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith("#") || trimmed === "")
-                continue;
-            if (/^\[/.test(trimmed)) {
-                inRootTable = false;
-                continue;
-            }
-            if (!inRootTable)
-                continue;
-            const m = /^model\s*=\s*"([^"]+)"/.exec(trimmed);
-            if (m)
-                return m[1];
-        }
-    }
-    catch {
-        // ignore
-    }
-    return undefined;
-}
-const RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 const DEFAULT_TTL = 60; // seconds
 const DEFAULT_TIMEOUT_MS = 15000;
-function windowFromHeaders(map, prefix) {
-    const suffixes = [
-        "used-percent",
-        "reset-after-seconds",
-        "reset-at",
-        "window-minutes",
-    ];
-    if (!suffixes.some((suffix) => map[`${prefix}-${suffix}`] !== undefined)) {
+const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
+// The old cache was populated from /backend-api/codex/responses headers. Keep
+// the new app-server snapshots in a separate namespace so an upgrade cannot
+// surface a model-specific response limit as the account's weekly limit.
+const CACHE_TOOL = "codex-app-server";
+function finiteNumber(value) {
+    if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) {
         return undefined;
     }
-    const usedPercent = num(map, `${prefix}-used-percent`) ?? 0;
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function quotaWindow(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const usedPercent = finiteNumber(value.usedPercent);
+    if (usedPercent === undefined)
+        return undefined;
+    const resetAt = finiteNumber(value.resetsAt);
+    const now = Math.floor(Date.now() / 1000);
     return {
         usedPercent,
         remainingPercent: Math.max(0, 100 - usedPercent),
-        resetAfterSeconds: num(map, `${prefix}-reset-after-seconds`),
-        resetAt: num(map, `${prefix}-reset-at`),
-        windowMinutes: num(map, `${prefix}-window-minutes`),
+        resetAt,
+        resetAfterSeconds: resetAt === undefined ? undefined : Math.max(0, resetAt - now),
+        windowMinutes: finiteNumber(value.windowDurationMins),
     };
 }
-/** Exported for protocol compatibility tests. */
-export function parseCodexHeaders(map, extras) {
-    const primary = windowFromHeaders(map, "x-codex-primary");
-    const secondary = windowFromHeaders(map, "x-codex-secondary");
-    // Codex CLI 0.144 removed the 5h limit. Its only Codex window is now the
-    // 10080-minute weekly window in `primary`, with `secondary` absent. Older
-    // responses used primary=5h and secondary=weekly, so prefer an explicitly
-    // weekly-sized window and then fall back to the legacy secondary position.
-    const weekly = [primary, secondary].find((window) => (window?.windowMinutes ?? 0) >= 7 * 24 * 60) ?? secondary ?? primary ?? { usedPercent: 0, remainingPercent: 0 };
+/** Normalize Codex app-server `account/rateLimits/read` into the manager shape. */
+export function parseCodexRateLimitsResponse(response, extras = {}) {
+    const payload = response && typeof response === "object"
+        ? response
+        : {};
+    // `rateLimits` is the official backward-compatible account bucket. Do not
+    // pick a model-specific entry from rateLimitsByLimitId: e.g. Spark can have
+    // a different weekly percentage from the main Codex account limit.
+    const snapshot = payload.rateLimits && typeof payload.rateLimits === "object"
+        ? payload.rateLimits
+        : undefined;
+    const windows = [quotaWindow(snapshot?.primary), quotaWindow(snapshot?.secondary)];
+    const weekly = windows.find((window) => (window?.windowMinutes ?? 0) >= WEEKLY_WINDOW_MINUTES);
+    const credits = snapshot?.credits && typeof snapshot.credits === "object"
+        ? {
+            hasCredits: snapshot.credits.hasCredits === true,
+            balance: nonEmptyString(snapshot.credits.balance),
+            unlimited: snapshot.credits.unlimited === true,
+        }
+        : undefined;
+    const limitId = nonEmptyString(snapshot?.limitId);
+    const limitName = nonEmptyString(snapshot?.limitName);
     return {
-        plan: str(map, "x-codex-plan-type"),
-        activeLimit: str(map, "x-codex-active-limit"),
+        plan: nonEmptyString(snapshot?.planType),
+        activeLimit: limitName ?? limitId,
         weekly,
-        credits: {
-            hasCredits: bool(map, "x-codex-credits-has-credits") ?? false,
-            balance: str(map, "x-codex-credits-balance"),
-            unlimited: bool(map, "x-codex-credits-unlimited") ?? false,
-        },
+        credits,
         email: extras.email,
         accountId: extras.accountId,
-        raw: Object.fromEntries(Object.entries(map).filter(([k]) => k.startsWith("x-codex-"))),
+        raw: payload,
+        ...(!weekly ? { error: "Codex rate-limit response has no weekly window" } : {}),
     };
 }
 export async function getCodexQuota(opts = {}) {
@@ -82,81 +77,75 @@ export async function getCodexQuota(opts = {}) {
     if (!authInfo.accessToken) {
         return emptyQuota("unknown", "codex auth.json missing access_token");
     }
-    const fp = fingerprintKey(["codex", authInfo.identityFingerprint ?? "unknown"]);
-    const file = cacheFile("codex", fp, opts.cacheDir);
+    const fp = fingerprintKey([CACHE_TOOL, authInfo.identityFingerprint ?? "unknown"]);
+    const file = cacheFile(CACHE_TOOL, fp, opts.cacheDir);
     if (!opts.forceRefresh && ttl > 0) {
         const cached = await readCache(file);
         if (isFresh(cached, ttl) && cached) {
-            return { ...withoutLegacyFiveHour(cached.value), source: "cached" };
+            return { ...cached.value, source: "cached" };
         }
     }
-    const model = opts.model ??
-        (await readConfiguredModel(opts.codexConfigPath ?? DEFAULT_CODEX_CONFIG)) ??
-        "gpt-5";
-    const body = JSON.stringify({
-        model,
-        instructions: "Reply with exactly one character.",
-        input: [
-            { type: "message", role: "user", content: [{ type: "input_text", text: "." }] },
-        ],
-        stream: true,
-        store: false,
-    });
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let res;
+    let response;
     try {
-        res = await fetch(RESPONSES_URL, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${authInfo.accessToken}`,
-                "Content-Type": "application/json",
-                "OpenAI-Beta": "responses=experimental",
-                ...(authInfo.accountId ? { "chatgpt-account-id": authInfo.accountId } : {}),
-            },
-            body,
-            signal: controller.signal,
+        response = await (opts.rateLimitsReader ?? readCodexRateLimits)({
+            codexAuthPath,
+            timeoutMs,
         });
     }
-    catch (err) {
-        clearTimeout(timer);
-        return await fallbackFromCache(file, ttl, err?.message ?? String(err));
-    }
-    // Abort the body stream immediately once headers are in; they're all we need.
-    try {
-        await res.body?.cancel();
-    }
-    catch {
-        // ignore
-    }
-    clearTimeout(timer);
-    const map = headersToMap(res.headers);
-    if (res.status === 401 || res.status === 403) {
-        return await fallbackFromCache(file, ttl, `auth failed: HTTP ${res.status}`);
+    catch (error) {
+        return fallbackFromCache(file, ttl, errorMessage(error));
     }
-    const parsed = parseCodexHeaders(map, {
+    const parsed = parseCodexRateLimitsResponse(response, {
         email: authInfo.email,
         accountId: authInfo.accountId,
     });
-    const now = Math.floor(Date.now() / 1000);
+    if (!parsed.weekly) {
+        return fallbackFromCache(file, ttl, parsed.error ?? "Codex weekly quota unavailable");
+    }
     const fresh = {
         tool: "codex",
-        fetchedAt: now,
+        fetchedAt: Math.floor(Date.now() / 1000),
         source: "fresh",
         ...parsed,
     };
-    // Only persist if we actually got rate-limit headers — otherwise the upstream was unhealthy.
-    if (Object.keys(fresh.raw ?? {}).length > 0) {
-        await writeCache(file, fresh);
-        return fresh;
+    await writeCache(file, fresh);
+    return fresh;
+}
+async function readCodexRateLimits(options) {
+    if (basename(options.codexAuthPath) !== "auth.json") {
+        throw new Error(`Codex app-server quota requires an active auth.json path; got ${options.codexAuthPath}`);
+    }
+    const transport = new CodexAppServerTransport({
+        env: { CODEX_HOME: dirname(options.codexAuthPath) },
+        ignoreCodexApiKey: true,
+    });
+    try {
+        return await withTimeout(transport.request("account/rateLimits/read"), options.timeoutMs, "Codex account/rateLimits/read timed out");
+    }
+    finally {
+        await transport.close();
+    }
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
     }
-    return await fallbackFromCache(file, ttl, `no x-codex-* headers on HTTP ${res.status}`);
 }
 async function fallbackFromCache(file, ttl, error) {
     const cached = await readCache(file);
     if (cached) {
         return {
-            ...withoutLegacyFiveHour(cached.value),
+            ...cached.value,
             source: isFresh(cached, ttl) ? "cached" : "stale",
             error,
         };
@@ -165,23 +154,21 @@ async function fallbackFromCache(file, ttl, error) {
 }
 /**
  * Read the on-disk quota cache for a given codex auth.json without triggering
- * any network call. Returns whatever snapshot was last written (regardless of
- * age) or `null` if nothing has been cached for this identity yet. Used by the
- * daemon's `list_accounts` handler to surface "last known" quota for inactive
- * accounts so the web UI can restore them across page refreshes.
+ * any network call. Only app-server snapshots are considered; legacy caches
+ * from response headers are intentionally ignored.
  */
 export async function readCachedCodexQuota(codexAuthPath, opts = {}) {
     try {
         const authInfo = await parseAuthFile(codexAuthPath);
         if (!authInfo.identityFingerprint)
             return null;
-        const fp = fingerprintKey(["codex", authInfo.identityFingerprint]);
-        const file = cacheFile("codex", fp, opts.cacheDir);
+        const fp = fingerprintKey([CACHE_TOOL, authInfo.identityFingerprint]);
+        const file = cacheFile(CACHE_TOOL, fp, opts.cacheDir);
         const entry = await readCache(file);
         if (!entry)
             return null;
         return {
-            ...withoutLegacyFiveHour(entry.value),
+            ...entry.value,
             source: "cached",
             fetchedAt: entry.fetchedAt,
         };
@@ -190,9 +177,8 @@ export async function readCachedCodexQuota(codexAuthPath, opts = {}) {
         return null;
     }
 }
-function withoutLegacyFiveHour(quota) {
-    const { fiveHour: _legacyFiveHour, ...current } = quota;
-    return current;
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 function emptyQuota(source, error) {
     return {
@@ -200,6 +186,5 @@ function emptyQuota(source, error) {
         source,
         error,
         fetchedAt: Math.floor(Date.now() / 1000),
-        weekly: { usedPercent: 0, remainingPercent: 0 },
     };
 }

package/dist/manager/types.d.ts

@@ -37,9 +37,7 @@ export interface CodexQuota {
     tool: "codex";
     plan?: string;
     activeLimit?: string;
-    /** @deprecated Codex CLI 0.144+ no longer exposes a 5h limit. */
-    fiveHour?: QuotaWindow;
-    weekly: QuotaWindow;
+    weekly?: QuotaWindow;
     credits?: {
         hasCredits: boolean;
         balance?: string;
@@ -49,7 +47,7 @@ export interface CodexQuota {
     source: QuotaSource;
     email?: string;
     accountId?: string;
-    raw?: Record<string, string>;
+    raw?: Record<string, unknown>;
     error?: string;
 }
 export interface ClaudeQuota {

package/dist/shared.js

@@ -280,8 +280,29 @@ export function extractLongFlagFromCommandLine(commandLine, flag) {
     return "";
 }
 export function resolveConductorConfigPath(configFilePath) {
-    const home = os.homedir();
-    return configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
+    if (configFilePath) {
+        return configFilePath;
+    }
+    const userHome = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    if (typeof process.env.CONDUCTOR_CONFIG === "string" && process.env.CONDUCTOR_CONFIG.trim()) {
+        const configuredPath = process.env.CONDUCTOR_CONFIG.trim();
+        const expandedPath = configuredPath === "~"
+            ? userHome
+            : configuredPath.startsWith("~/") || configuredPath.startsWith("~\\")
+                ? path.join(userHome, configuredPath.slice(2))
+                : configuredPath;
+        return path.resolve(expandedPath);
+    }
+    const configuredHome = typeof process.env.CONDUCTOR_HOME === "string" ? process.env.CONDUCTOR_HOME.trim() : "";
+    if (configuredHome) {
+        const expandedHome = configuredHome === "~"
+            ? userHome
+            : configuredHome.startsWith("~/") || configuredHome.startsWith("~\\")
+                ? path.join(userHome, configuredHome.slice(2))
+                : configuredHome;
+        return path.join(path.resolve(expandedHome), "config.yaml");
+    }
+    return path.join(userHome, ".conductor", "config.yaml");
 }
 export function loadYamlConfig(configFilePath) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -32,12 +32,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.7.4"
+    "@love-moon/chat-web": "^0.7.6"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "b9a27b4"
+  "gitCommitId": "c939df2"
 }