@love-moon/conductor-cli 0.7.5 → 0.7.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @love-moon/conductor-cli
 
+## 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.
+
+- Updated dependencies [7bbb412]
+  - @love-moon/conductor-sdk@0.7.6
+  - @love-moon/ai-sdk@0.7.6
+
 ## 0.7.5
 
 ### Patch Changes

package/bin/conductor-channel.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
@@ -10,6 +9,7 @@ import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { loadConfig } from "@love-moon/conductor-sdk";
 import { envForExplicitConfigFile } from "../src/config-env.js";
+import { resolveConductorConfigPath } from "../src/conductor-paths.js";
 
 const isMainModule = (() => {
   const currentFile = fileURLToPath(import.meta.url);
@@ -18,8 +18,7 @@ const isMainModule = (() => {
 })();
 
 function resolveDefaultConfigPath(env = process.env) {
-  const home = env.HOME || env.USERPROFILE || os.homedir();
-  return path.join(home, ".conductor", "config.yaml");
+  return resolveConductorConfigPath(undefined, env);
 }
 
 function readTextFile(filePath) {
@@ -55,7 +54,7 @@ export async function connectFeishuChannel(options = {}) {
     throw new Error("fetch is not available");
   }
 
-  const resolvedConfigPath = path.resolve(options.configFile || resolveDefaultConfigPath(env));
+  const resolvedConfigPath = resolveConductorConfigPath(options.configFile, env);
   const rawYaml = readTextFile(resolvedConfigPath);
   const config = loadConfig(resolvedConfigPath, {
     env: envForExplicitConfigFile(options.configFile, env),

package/bin/conductor-chrome.js

@@ -9,6 +9,7 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { launch as launchChrome } from 'chrome-launcher';
 import CDP from 'chrome-remote-interface';
+import { resolveConductorConfigPath } from '../src/conductor-paths.js';
 
 
 const BACKEND_URLS = {
@@ -52,7 +53,7 @@ const PAGE_AUTOMATION_PATH = new URL('pageAutomation.js', AUTOMATION_SRC_ROOT);
 const PROVIDERS_DIR = new URL('providers/', AUTOMATION_SRC_ROOT);
 let automationScriptCache;
 
-const CONFIG_PATH = path.join(homedir(), '.conductor', 'config.yaml');
+const CONFIG_PATH = resolveConductorConfigPath();
 
 function expandHomeDir(maybePath) {
   if (!maybePath) {
@@ -80,7 +81,7 @@ async function loadUserConfig() {
     }
   } catch (error) {
     if (error.code !== 'ENOENT') {
-      console.warn('Failed to read ~/.conductor/config.yaml:', error);
+      console.warn(`Failed to read ${CONFIG_PATH}:`, error);
     }
     cachedUserConfig = {};
   }

package/bin/conductor-config.js

@@ -9,9 +9,10 @@ import { execFileSync, execSync } from "node:child_process";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { RUNTIME_SUPPORTED_BACKENDS } from "../src/runtime-backends.js";
+import { resolveConductorConfigPath } from "../src/conductor-paths.js";
 
-const CONFIG_DIR = path.join(os.homedir(), ".conductor");
-const CONFIG_FILE = path.join(CONFIG_DIR, "config.yaml");
+const CONFIG_FILE = resolveConductorConfigPath();
+const CONFIG_DIR = path.dirname(CONFIG_FILE);
 const packageJson = JSON.parse(
   fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"),
 );
@@ -68,6 +69,9 @@ const defaultDaemonName = os.hostname() || "my-daemon";
 const cliVersion = packageJson.version || "unknown";
 const OPENCODE_INSTALL_URL = "https://opencode.ai/install";
 const OPENCODE_NPM_PACKAGE = "opencode-ai";
+const LEGACY_CONDUCTOR_PUBLIC_HOST = "conductor-ai.top";
+const CONDUCTOR_PUBLIC_HOST = "conductor.conductor-ai.top";
+const CONDUCTOR_PUBLIC_ORIGIN = "https://conductor.conductor-ai.top";
 
 const COLORS = {
   yellow: "\x1b[33m",
@@ -518,7 +522,9 @@ async function authorizeDeviceAndGetToken() {
   console.log(colorize("Open this link in your browser to authorize this device:", "cyan"));
   console.log("");
   console.log(`Device code: ${colorize(startData.user_code, "bold")}`);
-  console.log(`Direct link: ${startData.verification_uri_complete}`);
+  console.log(
+    `Direct link: ${normalizeOfficialConductorUrl(startData.verification_uri_complete, backendUrl)}`,
+  );
   console.log("");
   console.log("Only approve the request if the web page shows the same device code.");
   console.log("");
@@ -551,10 +557,17 @@ async function authorizeDeviceAndGetToken() {
       continue;
     }
     if (pollData.status === "approved") {
+      const resolvedBackendUrl = normalizeOfficialConductorUrl(
+        pollData.backend_url || backendUrl,
+        backendUrl,
+      );
       const result = {
         agentToken: pollData.agent_token,
-        backendUrl: pollData.backend_url || backendUrl,
-        websocketUrl: pollData.websocket_url || null,
+        backendUrl: resolvedBackendUrl,
+        websocketUrl: normalizeOfficialConductorUrl(
+          pollData.websocket_url || null,
+          backendUrl,
+        ),
       };
       lastDeviceAuthConfig = result;
       console.log(colorize("✓ Device authorized", "green"));
@@ -571,6 +584,43 @@ async function authorizeDeviceAndGetToken() {
   throw new Error("Device authorization timed out");
 }
 
+function isOfficialConductorBackend(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return false;
+  }
+  try {
+    const hostname = new URL(value).hostname;
+    return hostname === LEGACY_CONDUCTOR_PUBLIC_HOST || hostname === CONDUCTOR_PUBLIC_HOST;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeOfficialConductorUrl(value, requestBackendUrl) {
+  if (typeof value !== "string" || !value.trim()) {
+    return value;
+  }
+  if (!isOfficialConductorBackend(requestBackendUrl)) {
+    return value;
+  }
+
+  try {
+    const parsed = new URL(value);
+    if (parsed.hostname !== LEGACY_CONDUCTOR_PUBLIC_HOST) {
+      return value;
+    }
+
+    const canonicalOrigin = new URL(CONDUCTOR_PUBLIC_ORIGIN);
+    parsed.protocol = parsed.protocol === "ws:" || parsed.protocol === "wss:"
+      ? "wss:"
+      : canonicalOrigin.protocol;
+    parsed.host = canonicalOrigin.host;
+    return parsed.toString();
+  } catch {
+    return value;
+  }
+}
+
 async function parseJsonResponse(response) {
   try {
     return await response.json();

package/bin/conductor-daemon.js

@@ -9,10 +9,16 @@ import { hideBin } from "yargs/helpers";
 import yaml from "js-yaml";
 
 import { startDaemon } from "../src/daemon.js";
+import {
+  materializeConductorPathEnv,
+  resolveConductorConfigPath,
+  resolveConductorHome,
+} from "../src/conductor-paths.js";
 
 const argv = hideBin(process.argv);
 
 const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor-daemon";
+const CONDUCTOR_HOME = resolveConductorHome();
 
 function parseJsonArrayEnv(value) {
   if (typeof value !== "string" || !value.trim()) {
@@ -75,8 +81,7 @@ function formatBeijingTimestampForFile(date = new Date()) {
 
 function loadUserConfig(configFilePath) {
   try {
-    const home = os.homedir();
-    const configPath = configFilePath || path.join(home, ".conductor", "config.yaml");
+    const configPath = resolveConductorConfigPath(configFilePath);
     if (!fs.existsSync(configPath)) {
       return {};
     }
@@ -146,7 +151,7 @@ const args = yargs(argv)
   .option("nohup", {
     type: "boolean",
     default: false,
-    describe: "Run in background and write logs to ~/.conductor/logs/<timestamp>.log",
+    describe: `Run in background and write logs to ${path.join(CONDUCTOR_HOME, "logs", "<timestamp>.log")}`,
   })
   .option("force", {
     type: "boolean",
@@ -162,15 +167,21 @@ const args = yargs(argv)
     type: "string",
     describe: "Path to Conductor config file",
   })
-  .example("$0 --config-file ~/.conductor/config.yaml", "Run with daemon_name from config")
+  .example(`$0 --config-file ${resolveConductorConfigPath()}`, "Run with daemon_name from config")
   .example("$0 --nohup", "Run daemon in background with logfile")
   .example("$0 --nohup --force", "Restart daemon in background by stopping the existing one")
   .help()
   .strict()
   .parse();
 
+const materializedConductorPathEnv = materializeConductorPathEnv(args.configFile);
+Object.assign(process.env, materializedConductorPathEnv);
+const effectiveConfigFile = args.configFile
+  ? materializedConductorPathEnv.CONDUCTOR_CONFIG
+  : undefined;
+
 if (args.nohup) {
-  const workspaceRoot = resolveWorkspaceRoot(args.configFile);
+  const workspaceRoot = resolveWorkspaceRoot(effectiveConfigFile);
   const runningPid = findRunningDaemonPid(workspaceRoot);
   if (runningPid && !args.force) {
     process.stderr.write(
@@ -179,7 +190,7 @@ if (args.nohup) {
     process.exit(1);
   }
 
-  const logsDir = path.join(os.homedir(), ".conductor", "logs");
+  const logsDir = path.join(resolveConductorHome(), "logs");
   fs.mkdirSync(logsDir, { recursive: true });
   const timestamp = formatBeijingTimestampForFile(new Date());
   const logPath = path.join(logsDir, `${timestamp}.log`);
@@ -197,7 +208,7 @@ if (args.nohup) {
 
 startDaemon({
   CLEAN_ALL: args.cleanAll,
-  CONFIG_FILE: args.configFile,
+  CONFIG_FILE: effectiveConfigFile,
   FORCE: args.force,
   ...resolveLauncherConfig(),
 });

package/bin/conductor-fire.js

@@ -36,6 +36,7 @@ import {
   normalizeRuntimeBackendAlias,
   normalizeRuntimeBackendName,
 } from "../src/runtime-backends.js";
+import { resolveConductorConfigPath, resolveConductorHome } from "../src/conductor-paths.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -111,8 +112,7 @@ export function shouldFireReportTaskStatus({ launchedByDaemon = false, phase } =
 
 // Load allow_cli_list from config file (no defaults - must be configured)
 function loadFireConfigYaml(configFilePath) {
-  const home = os.homedir();
-  const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
+  const configPath = resolveConductorConfigPath(configFilePath);
   try {
     if (fs.existsSync(configPath)) {
       const content = fs.readFileSync(configPath, "utf8");
@@ -313,14 +313,14 @@ function resolveLockWorkingDirectory(workingDirectory) {
   }
 }
 
-export function resolveFreshSessionBootstrapLockPath(backendName, workingDirectory) {
+export function resolveFreshSessionBootstrapLockPath(backendName, workingDirectory, env = process.env) {
   const normalizedBackend = String(backendName || "").trim().toLowerCase();
   if (normalizedBackend !== "codex") {
     return null;
   }
   const lockKey = `${normalizedBackend}:${resolveLockWorkingDirectory(workingDirectory)}`;
   const digest = createHash("sha1").update(lockKey).digest("hex");
-  return path.join(os.homedir(), ".conductor", "locks", `session-bootstrap-${digest}.lock`);
+  return path.join(resolveConductorHome(env), "locks", `session-bootstrap-${digest}.lock`);
 }
 
 function acquireFileLock(lockPath) {
@@ -605,7 +605,7 @@ async function main() {
       if (discoveryError) {
         throw discoveryError;
       }
-      process.stdout.write(`No supported backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    kimi: kimi\n    opencode: opencode\n`);
+      process.stdout.write(`No supported backends configured.\n\nAdd allow_cli_list to your config file (${resolveConductorConfigPath(cliArgs.configFile)}):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    kimi: kimi\n    opencode: opencode\n`);
     } else {
       if (supportedBackends.length > 0) {
         process.stdout.write(`Supported backends (from config):\n`);
@@ -1306,6 +1306,7 @@ export async function parseCliArgs(argvInput = process.argv) {
   // Handle help early
   if (helpWithoutSeparator) {
     const defaultBackend = supportedBackends[0] || externalBackends[0] || "none";
+    const defaultConfigPath = resolveConductorConfigPath(configFileFromArgs);
     process.stdout.write(`${CLI_NAME} - Conductor-aware AI coding agent runner
 
 Usage: ${CLI_NAME} [options] -- [backend options and prompt]
@@ -1320,7 +1321,7 @@ Options:
   -v, --version         Show Conductor CLI version and exit
   -h, --help            Show this help message
 
-Config file format (~/.conductor/config.yaml):
+Config file format (${defaultConfigPath}):
   allow_cli_list:
     codex: codex --dangerously-bypass-approvals-and-sandbox
     claude: claude --dangerously-skip-permissions
@@ -1335,9 +1336,11 @@ Examples:
   ${CLI_NAME} --backend codex --resume <id>       # Resume Codex session
   ${CLI_NAME} --backend kimi --resume <id>        # Resume Kimi session
   ${CLI_NAME} --list-backends                     # Show configured backends
-  ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
+  ${CLI_NAME} --config-file ${defaultConfigPath} -- "fix the bug"
 
 Environment:
+  CONDUCTOR_HOME        User data directory [default: ~/.conductor]
+  CONDUCTOR_CONFIG      Config file override (takes precedence over CONDUCTOR_HOME)
   CONDUCTOR_BACKEND     Default backend
   CONDUCTOR_PROJECT_ID  Project ID to attach to
   CONDUCTOR_TASK_ID     Attach to existing task instead of creating new one
@@ -1460,30 +1463,31 @@ function normalizeTaskId(value) {
   return value.trim();
 }
 
-function resolveFireStateDir(workingDirectory) {
+export function resolveFireStateDir(workingDirectory, env = process.env) {
   // Priority:
   //   1. CONDUCTOR_FIRE_STATE_DIR env override (used by tests to isolate the
   //      marker dir into a tmpdir; also handy for ops to relocate state).
-  //   2. Explicit `workingDirectory` argument (legacy callers).
-  //   3. ~/.conductor/state — matches the conductor convention used by the
-  //      session bootstrap locks (see line ~311).
+  //   2. Explicit `workingDirectory` argument. Production marker writes use
+  //      this project-scoped path so commands such as send-file can discover
+  //      the active task while walking up from the current directory.
+  //   3. $CONDUCTOR_HOME/state (defaults to ~/.conductor/state) only when no
+  //      project working directory is available.
   //
   // We deliberately do NOT default to process.cwd(), which would pollute
   // every project directory a user runs `conductor fire` from and cause tests
   // to leak marker files into the repo.
   const envOverride =
-    typeof process.env.CONDUCTOR_FIRE_STATE_DIR === "string" &&
-    process.env.CONDUCTOR_FIRE_STATE_DIR.trim()
-      ? process.env.CONDUCTOR_FIRE_STATE_DIR.trim()
+    typeof env.CONDUCTOR_FIRE_STATE_DIR === "string" &&
+    env.CONDUCTOR_FIRE_STATE_DIR.trim()
+      ? env.CONDUCTOR_FIRE_STATE_DIR.trim()
       : "";
   if (envOverride) {
     return path.resolve(envOverride);
   }
-  const baseDir =
-    typeof workingDirectory === "string" && workingDirectory.trim()
-      ? path.resolve(workingDirectory.trim())
-      : os.homedir();
-  return path.join(baseDir, ".conductor", "state");
+  if (typeof workingDirectory === "string" && workingDirectory.trim()) {
+    return path.join(path.resolve(workingDirectory.trim()), ".conductor", "state");
+  }
+  return path.join(resolveConductorHome(env), "state");
 }
 
 /**

package/bin/conductor-send-file.js

@@ -2,7 +2,6 @@
 
 import fs from "node:fs";
 import fsp from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
@@ -11,9 +10,9 @@ import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { ConductorConfig, loadConfig } from "@love-moon/conductor-sdk";
 import { envForExplicitConfigFile } from "../src/config-env.js";
+import { resolveConductorConfigPath } from "../src/conductor-paths.js";
 
 const DEFAULT_MIME_TYPE = "application/octet-stream";
-const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".conductor", "config.yaml");
 const FIRE_TASK_MARKER_PREFIX = "active-fire";
 
 const EXTENSION_TO_MIME = {
@@ -110,7 +109,7 @@ export function detectTaskId(options = {}) {
 }
 
 function loadCliConfig(configFile, env = process.env) {
-  const configPath = configFile ? path.resolve(configFile) : DEFAULT_CONFIG_PATH;
+  const configPath = resolveConductorConfigPath(configFile, env);
   const configEnv = envForExplicitConfigFile(configFile, env);
   if (fs.existsSync(configPath)) {
     return loadConfig(configPath, { env: configEnv });

package/bin/conductor-serve-ai.js

@@ -117,7 +117,7 @@ async function main() {
             default: false,
             describe: "Overwrite an existing config-ai-serve.yaml",
           })
-          .example("$0 init", "Create ~/.conductor/config-ai-serve.yaml")
+          .example("$0 init", "Create config-ai-serve.yaml under CONDUCTOR_HOME")
           .example("$0 init --config-file /tmp/custom/config.yaml", "Create /tmp/custom/config-ai-serve.yaml"),
       async (args) => {
         const { conductorConfigPath, serveAiConfigPath } = resolveServeAiConfigPaths(args.configFile);

package/bin/conductor.js

@@ -140,6 +140,10 @@ Options:
   -h, --help     Show this help message
   -v, --version  Show version information
 
+Environment:
+  CONDUCTOR_HOME    User data directory (default: ~/.conductor)
+  CONDUCTOR_CONFIG  Config file override (takes precedence over CONDUCTOR_HOME)
+
 Examples:
   conductor fire -- "fix the bug"
   conductor fire --backend claude -- "add feature"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.7.5",
-  "gitCommitId": "702c7c4",
+  "version": "0.7.6",
+  "gitCommitId": "c939df2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -24,8 +24,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.7.5",
-    "@love-moon/conductor-sdk": "0.7.5",
+    "@love-moon/ai-sdk": "0.7.6",
+    "@love-moon/conductor-sdk": "0.7.6",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -38,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.7.5"
+    "@love-moon/chat-web": "0.7.6"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/ai-manager-handlers.js

@@ -9,7 +9,7 @@ const BASE_QUOTA_TOOLS = ["codex", "claude", "kimi", "copilot"];
 
 /**
  * @param {object} opts
- * @param {string} [opts.configPath] Path to ~/.conductor/config.yaml. Defaults to the manager facade default.
+ * @param {string} [opts.configPath] Path to config.yaml. Defaults to $CONDUCTOR_HOME/config.yaml.
  */
 export function createAiManagerHandlers(opts = {}) {
   const manager = new AiManager(opts.configPath ? { configPath: opts.configPath } : undefined);

package/src/cli-update-notifier.js

@@ -1,8 +1,8 @@
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 
 import { buildUpgradeCommand, fetchLatestVersion, isNewerVersion } from "./version-check.js";
+import { resolveConductorHome } from "./conductor-paths.js";
 
 export const DEFAULT_VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 export const DEFAULT_VERSION_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -44,8 +44,13 @@ function isTimestampOlderThan(value, ageMs, nowMs) {
 }
 
 export function resolveVersionCheckCachePath(options = {}) {
-  const homeDir = options.homeDir || process.env.HOME || os.homedir() || "/tmp";
-  return path.join(homeDir, ".conductor", DEFAULT_CACHE_FILE);
+  const env = options.env || process.env;
+  const conductorHome = options.conductorHome
+    ? path.resolve(options.conductorHome)
+    : options.homeDir
+      ? resolveConductorHome({}, { userHome: options.homeDir })
+      : resolveConductorHome(env);
+  return path.join(conductorHome, DEFAULT_CACHE_FILE);
 }
 
 export function normalizeVersionCheckCache(value) {
@@ -171,7 +176,9 @@ export async function maybeCheckForUpdates(options = {}) {
   const fetchLatestVersionFn = options.fetchLatestVersion || fetchLatestVersion;
   const cacheOptions = {
     cachePath: options.cachePath,
-    homeDir: options.homeDir || env.HOME,
+    conductorHome: options.conductorHome,
+    homeDir: options.homeDir,
+    env,
     readFile: options.readFile,
     writeFile: options.writeFile,
     mkdir: options.mkdir,

package/src/conductor-paths.js

@@ -0,0 +1,61 @@
+import os from "node:os";
+import path from "node:path";
+
+export const CONDUCTOR_HOME_ENV_VAR = "CONDUCTOR_HOME";
+export const CONDUCTOR_CONFIG_ENV_VAR = "CONDUCTOR_CONFIG";
+
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+export function resolveUserHome(env = process.env, fallbackHome = os.homedir()) {
+  return (
+    normalizeOptionalString(env?.HOME) ||
+    normalizeOptionalString(env?.USERPROFILE) ||
+    normalizeOptionalString(fallbackHome) ||
+    "/tmp"
+  );
+}
+
+export function resolveHomeRelativePath(value, env = process.env, fallbackHome = os.homedir()) {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return "";
+  }
+  const userHome = resolveUserHome(env, fallbackHome);
+  if (normalized === "~") {
+    return path.resolve(userHome);
+  }
+  if (normalized.startsWith("~/") || normalized.startsWith("~\\")) {
+    return path.resolve(userHome, normalized.slice(2));
+  }
+  return path.resolve(normalized);
+}
+
+export function resolveConductorHome(env = process.env, options = {}) {
+  const configuredHome = normalizeOptionalString(env?.[CONDUCTOR_HOME_ENV_VAR]);
+  if (configuredHome) {
+    return resolveHomeRelativePath(configuredHome, env, options.fallbackHome);
+  }
+  const userHome = normalizeOptionalString(options.userHome) || resolveUserHome(env, options.fallbackHome);
+  return path.join(path.resolve(userHome), ".conductor");
+}
+
+export function resolveConductorConfigPath(configFile, env = process.env, options = {}) {
+  const explicitPath = normalizeOptionalString(configFile);
+  if (explicitPath) {
+    return resolveHomeRelativePath(explicitPath, env, options.fallbackHome);
+  }
+  const configuredPath = normalizeOptionalString(env?.[CONDUCTOR_CONFIG_ENV_VAR]);
+  if (configuredPath) {
+    return resolveHomeRelativePath(configuredPath, env, options.fallbackHome);
+  }
+  return path.join(resolveConductorHome(env, options), "config.yaml");
+}
+
+export function materializeConductorPathEnv(configFile, env = process.env, options = {}) {
+  return {
+    CONDUCTOR_HOME: resolveConductorHome(env, options),
+    CONDUCTOR_CONFIG: resolveConductorConfigPath(configFile, env, options),
+  };
+}

package/src/custom-command-handlers.js

@@ -7,6 +7,8 @@ import { randomUUID } from "node:crypto";
 
 import yaml from "js-yaml";
 
+import { resolveConductorConfigPath } from "./conductor-paths.js";
+
 const VALID_ACTIONS = new Set(["list", "run", "status"]);
 const MAX_TAIL_CHARS = 12_000;
 const MAX_RUNS = 200;
@@ -25,7 +27,7 @@ export const CUSTOM_COMMANDS_CAPABILITY = "custom_commands";
  * @param {typeof spawn} [opts.spawnFn]
  */
 export function createCustomCommandHandlers(opts = {}) {
-  const configPath = opts.configPath || path.join(os.homedir(), ".conductor", "config.yaml");
+  const configPath = resolveConductorConfigPath(opts.configPath);
   const spawnFn = opts.spawnFn || spawn;
   const runs = new Map();
   const runningByKey = new Map();
@@ -202,7 +204,7 @@ export async function loadCustomCommands(configPath) {
  * @param {string} configPath
  * @returns {CustomCommand[]}
  */
-export function parseCustomCommandsConfig(config, configPath = path.join(os.homedir(), ".conductor", "config.yaml")) {
+export function parseCustomCommandsConfig(config, configPath = resolveConductorConfigPath()) {
   const root = config && typeof config === "object" ? config : {};
   const rawCommands = root.custom_commands;
   if (rawCommands === undefined || rawCommands === null) {

package/src/daemon.js

@@ -17,6 +17,11 @@ import {
 } from "@love-moon/conductor-sdk";
 import { DaemonLogCollector } from "./log-collector.js";
 import { envForExplicitConfigFile } from "./config-env.js";
+import {
+  materializeConductorPathEnv,
+  resolveConductorConfigPath,
+  resolveConductorHome,
+} from "./conductor-paths.js";
 import { createAiManagerHandlers, handleAiManagerRequest } from "./ai-manager-handlers.js";
 import {
   CUSTOM_COMMANDS_CAPABILITY,
@@ -62,8 +67,6 @@ const __dirname = path.dirname(__filename);
 const PACKAGE_ROOT = path.join(__dirname, "..");
 const moduleRequire = createRequire(import.meta.url);
 const CLI_PATH = path.resolve(PACKAGE_ROOT, "bin", "conductor-fire.js");
-const DAEMON_LOG_DIR = path.join(os.homedir(), ".conductor", "logs");
-const DAEMON_LOG_PATH = path.join(DAEMON_LOG_DIR, "conductor-daemon.log");
 const CLI_VERSION = (() => {
   try {
     return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8")).version;
@@ -71,6 +74,14 @@ const CLI_VERSION = (() => {
     return "unknown";
   }
 })();
+
+export function resolveDaemonLogPaths(env = process.env) {
+  const logDir = path.join(resolveConductorHome(env), "logs");
+  return {
+    logDir,
+    logPath: path.join(logDir, "conductor-daemon.log"),
+  };
+}
 const PLAN_LIMIT_MESSAGES = {
   manual_fire_active_task: "Free plan limit reached: only 1 active fire task is allowed.",
   app_active_task: "Free plan limit reached: only 1 active app task is allowed.",
@@ -119,8 +130,9 @@ export function probePtyTaskCapability({
 
 function appendDaemonLog(line) {
   try {
-    fs.mkdirSync(DAEMON_LOG_DIR, { recursive: true });
-    fs.appendFileSync(DAEMON_LOG_PATH, line);
+    const { logDir, logPath } = resolveDaemonLogPaths();
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(logPath, line);
   } catch {
     // ignore file log errors
   }
@@ -156,8 +168,7 @@ function sleepSync(ms) {
 
 function getUserConfig(configFilePath) {
   try {
-    const home = os.homedir();
-    const configPath = configFilePath || path.join(home, ".conductor", "config.yaml");
+    const configPath = resolveConductorConfigPath(configFilePath);
     if (fs.existsSync(configPath)) {
       const content = fs.readFileSync(configPath, "utf8");
       const parsed = yaml.load(content);
@@ -179,7 +190,7 @@ function getUserConfig(configFilePath) {
 //
 // Resolution order:
 //   1. CONDUCTOR_FIRE_TMUX_MODE env var ("1"/"true"/"on" enable, "0"/"false"/"off" disable)
-//   2. fire_tmux_mode boolean in ~/.conductor/config.yaml
+//   2. fire_tmux_mode boolean in the resolved Conductor config.yaml
 //   3. Default: false
 function getFireTmuxModeEnabled(userConfig) {
   const rawEnv = process.env.CONDUCTOR_FIRE_TMUX_MODE;
@@ -669,10 +680,15 @@ export function startDaemon(config = {}, deps = {}) {
   };
 
   let fileConfig;
+  const materializedConductorPathEnv = materializeConductorPathEnv(
+    config.CONFIG_FILE,
+    process.env,
+  );
+  const effectiveConfigPath = materializedConductorPathEnv.CONDUCTOR_CONFIG;
   const configFileEnv = envForExplicitConfigFile(config.CONFIG_FILE, process.env);
   try {
     fileConfig = loadConfig(config.CONFIG_FILE, { env: configFileEnv });
-    log(`Loaded config from ${config.CONFIG_FILE || "~/.conductor/config.yaml"}`);
+    log(`Loaded config from ${effectiveConfigPath}`);
   } catch (err) {
     if (!(err instanceof ConfigFileNotFound)) {
       log(`Failed to load config: ${err.message}`);
@@ -712,7 +728,7 @@ export function startDaemon(config = {}, deps = {}) {
     os.hostname()
   ).trim();
   if (!AGENT_NAME) {
-    logError("Daemon name is required. Set daemon_name in ~/.conductor/config.yaml or CONDUCTOR_DAEMON_NAME.");
+    logError(`Daemon name is required. Set daemon_name in ${effectiveConfigPath} or CONDUCTOR_DAEMON_NAME.`);
     return exitAndReturn(1);
   }
   const homeDir = process.env.HOME || os.homedir() || "/tmp";
@@ -2144,8 +2160,8 @@ export function startDaemon(config = {}, deps = {}) {
   if (advertisedCapabilities.length > 0) {
     extraHeaders["x-conductor-capabilities"] = advertisedCapabilities.join(",");
   }
-  const aiManagerHandlers = createAiManagerHandlers({ configPath: config.CONFIG_FILE });
-  const customCommandHandlers = createCustomCommandHandlers({ configPath: config.CONFIG_FILE });
+  const aiManagerHandlers = createAiManagerHandlers({ configPath: effectiveConfigPath });
+  const customCommandHandlers = createCustomCommandHandlers({ configPath: effectiveConfigPath });
 
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
@@ -2690,15 +2706,16 @@ export function startDaemon(config = {}, deps = {}) {
 
     let logFd = null;
     if (shouldRespawn) {
+      const { logDir: daemonLogDir, logPath: daemonLogPath } = resolveDaemonLogPaths();
       try {
-        mkdirSyncFn(DAEMON_LOG_DIR, { recursive: true });
+        mkdirSyncFn(daemonLogDir, { recursive: true });
       } catch {
         /* ignore */
       }
-      logFd = fs.openSync(DAEMON_LOG_PATH, "a");
+      logFd = fs.openSync(daemonLogPath, "a");
       if (!isBackgroundProcess) {
         log(
-          `[${reason}] Foreground daemon will be respawned in background. Logs: ${DAEMON_LOG_PATH}`
+          `[${reason}] Foreground daemon will be respawned in background. Logs: ${daemonLogPath}`
         );
       }
     }
@@ -2719,6 +2736,7 @@ export function startDaemon(config = {}, deps = {}) {
           stdio: ["ignore", logFd, logFd],
           env: {
             ...process.env,
+            ...materializedConductorPathEnv,
             CONDUCTOR_LOCK_HANDOFF_TOKEN: handoffToken,
             CONDUCTOR_LOCK_HANDOFF_FROM_PID: String(process.pid),
             CONDUCTOR_LOCK_HANDOFF_EXPIRES_AT: String(handoffExpiresAt),
@@ -5272,15 +5290,13 @@ export function startDaemon(config = {}, deps = {}) {
 
       const env = {
         ...stripPtyTaskScopedEnv(process.env),
+        ...materializedConductorPathEnv,
         PWD: taskDir,
         CONDUCTOR_PROJECT_ID: projectId,
         CONDUCTOR_TASK_ID: taskId,
         CONDUCTOR_LAUNCHED_BY_DAEMON: "1",
         ...(cliCommand ? { CONDUCTOR_CLI_COMMAND: cliCommand } : {}),
       };
-      if (config.CONFIG_FILE) {
-        env.CONDUCTOR_CONFIG = config.CONFIG_FILE;
-      }
       if (AGENT_TOKEN) {
         env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
       }
@@ -5915,6 +5931,7 @@ export function startDaemon(config = {}, deps = {}) {
 
     const env = {
       ...stripPtyTaskScopedEnv(process.env),
+      ...materializedConductorPathEnv,
       PWD: taskDir,
       CONDUCTOR_PROJECT_ID: normalizedProjectId,
       CONDUCTOR_TASK_ID: normalizedTargetTaskId,
@@ -5922,9 +5939,6 @@ export function startDaemon(config = {}, deps = {}) {
       ...(cliCommand ? { CONDUCTOR_CLI_COMMAND: cliCommand } : {}),
     };
     env.CONDUCTOR_RESUME_CWD = resolvedResumeCwd;
-    if (config.CONFIG_FILE) {
-      env.CONDUCTOR_CONFIG = config.CONFIG_FILE;
-    }
     if (AGENT_TOKEN) {
       env.CONDUCTOR_AGENT_TOKEN = AGENT_TOKEN;
     }

package/src/entity-helpers.js

@@ -15,12 +15,12 @@
  */
 
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 
 import { envForExplicitConfigFile } from "./config-env.js";
+import { resolveConductorConfigPath } from "./conductor-paths.js";
 
 // RFC §4 exit codes
 export const EXIT = {
@@ -50,14 +50,8 @@ export function getCliVersion() {
   return cachedPkgVersion;
 }
 
-const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".conductor", "config.yaml");
-
 export function resolveConfigPath(configFile, env = process.env) {
-  if (configFile) {
-    return path.resolve(configFile);
-  }
-  const home = env.HOME || env.USERPROFILE || os.homedir();
-  return path.join(home, ".conductor", "config.yaml");
+  return resolveConductorConfigPath(configFile, env);
 }
 
 /**

package/src/fire/resume.js

@@ -1,6 +1,5 @@
 import crypto from "node:crypto";
 import { promises as fsp } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
 import yaml from "js-yaml";
@@ -19,6 +18,7 @@ import {
   normalizeRuntimeBackendAlias,
   resolveConfiguredRuntimeBackend,
 } from "../runtime-backends.js";
+import { resolveConductorConfigPath, resolveConductorHome } from "../conductor-paths.js";
 
 function normalizeBackend(backend) {
   return String(backend || "").trim().toLowerCase();
@@ -28,23 +28,23 @@ function normalizeSessionId(sessionId) {
   return typeof sessionId === "string" ? sessionId.trim() : "";
 }
 
-function resolveHomeDir(options) {
-  if (options?.homeDir) {
-    return options.homeDir;
+function resolveConductorStorageDir(options = {}) {
+  if (typeof options.conductorHome === "string" && options.conductorHome.trim()) {
+    return path.resolve(options.conductorHome.trim());
   }
-  return os.homedir();
+  const env = options.env || process.env;
+  if (typeof options.homeDir === "string" && options.homeDir.trim()) {
+    return resolveConductorHome(env, { userHome: options.homeDir.trim() });
+  }
+  return resolveConductorHome(env);
 }
 
 function resolveConfigFilePath(options = {}) {
-  const configuredPath =
-    typeof options?.configFilePath === "string" && options.configFilePath.trim()
-      ? options.configFilePath.trim()
-      : typeof process.env.CONDUCTOR_CONFIG === "string" && process.env.CONDUCTOR_CONFIG.trim()
-        ? process.env.CONDUCTOR_CONFIG.trim()
-        : "";
-  return configuredPath
-    ? path.resolve(configuredPath)
-    : path.join(resolveHomeDir(options), ".conductor", "config.yaml");
+  const env = options.env || process.env;
+  if (typeof options.homeDir === "string" && options.homeDir.trim() && !env.CONDUCTOR_HOME) {
+    return resolveConductorConfigPath(options.configFilePath, env, { userHome: options.homeDir.trim() });
+  }
+  return resolveConductorConfigPath(options.configFilePath, env);
 }
 
 function normalizeProjectPathCandidate(value) {
@@ -93,10 +93,10 @@ function md5Hex(value) {
 }
 
 async function loadConductorSessionRecords(options = {}) {
-  const homeDir = resolveHomeDir(options);
+  const conductorHome = resolveConductorStorageDir(options);
   const defaultPaths = [
-    path.join(homeDir, ".conductor", "session.yaml"),
-    path.join(homeDir, ".conductor", "sessions"),
+    path.join(conductorHome, "session.yaml"),
+    path.join(conductorHome, "sessions"),
   ];
   const recordFiles = [];
   const pushFile = (filePath) => {

package/src/runtime-backends.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from "node:url";
 
 import yaml from "js-yaml";
 import { BUILT_IN_BACKENDS as AI_SDK_BUILT_IN_BACKENDS } from "@love-moon/ai-sdk";
+import { resolveConductorConfigPath } from "./conductor-paths.js";
 
 // CLI display order for built-in backends. ai-sdk owns the canonical set of
 // built-in backends; CLI just picks an ordering for "Supported Backends:" log
@@ -349,10 +350,7 @@ export function isCommandOptionalBuiltInRuntimeBackend(backend) {
 }
 
 function readConfigEnvValue(configFilePath, key) {
-  const targetPath =
-    typeof configFilePath === "string" && configFilePath.trim()
-      ? path.resolve(configFilePath.trim())
-      : path.join(process.env.HOME || "", ".conductor", "config.yaml");
+  const targetPath = resolveConductorConfigPath(configFilePath);
   try {
     if (!targetPath || !fs.existsSync(targetPath)) {
       return "";

package/src/serve-ai/config.js

@@ -1,24 +1,18 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
 import yaml from "js-yaml";
+import { resolveConductorConfigPath } from "../conductor-paths.js";
 
 export const DEFAULT_CONDUCTOR_CONFIG_BASENAME = "config.yaml";
 export const DEFAULT_SERVE_AI_CONFIG_BASENAME = "config-ai-serve.yaml";
 
-function resolvePrimaryConfigPath(configFilePath) {
-  if (typeof configFilePath === "string" && configFilePath.trim()) {
-    return path.resolve(configFilePath.trim());
-  }
-  if (typeof process.env.CONDUCTOR_CONFIG === "string" && process.env.CONDUCTOR_CONFIG.trim()) {
-    return path.resolve(process.env.CONDUCTOR_CONFIG.trim());
-  }
-  return path.join(os.homedir(), ".conductor", DEFAULT_CONDUCTOR_CONFIG_BASENAME);
+function resolvePrimaryConfigPath(configFilePath, env = process.env) {
+  return resolveConductorConfigPath(configFilePath, env);
 }
 
-export function resolveServeAiConfigPaths(configFilePath) {
-  const conductorConfigPath = resolvePrimaryConfigPath(configFilePath);
+export function resolveServeAiConfigPaths(configFilePath, env = process.env) {
+  const conductorConfigPath = resolvePrimaryConfigPath(configFilePath, env);
   return {
     conductorConfigPath,
     serveAiConfigPath: path.join(path.dirname(conductorConfigPath), DEFAULT_SERVE_AI_CONFIG_BASENAME),
@@ -37,8 +31,8 @@ function parseYamlFile(filePath) {
   return parsed;
 }
 
-export function loadServeAiRuntimeConfig(configFilePath) {
-  const { conductorConfigPath, serveAiConfigPath } = resolveServeAiConfigPaths(configFilePath);
+export function loadServeAiRuntimeConfig(configFilePath, env = process.env) {
+  const { conductorConfigPath, serveAiConfigPath } = resolveServeAiConfigPaths(configFilePath, env);
   const conductorExists = fs.existsSync(conductorConfigPath);
   const serveAiExists = fs.existsSync(serveAiConfigPath);