@reconcrap/boss-recommend-mcp 1.3.34 → 1.3.36

package/src/cli.js

@@ -18,10 +18,12 @@ import {
 } from "./adapters.js";
 import {
   cancelBossChatRun,
+  ensureBossChatRuntimeReady,
   getBossChatHealthCheck,
   getBossChatRun,
   pauseBossChatRun,
   prepareBossChatRun,
+  resolveBossChatRuntimeLayout,
   resumeBossChatRun,
   startBossChatRun
 } from "./boss-chat.js";
@@ -742,30 +744,22 @@ function ensureUserConfig(options = {}) {
   throw lastError || new Error("No writable target for screening-config.json");
 }
 
-function getBossChatDataDir(workspaceRoot) {
-  return path.join(path.resolve(String(workspaceRoot || process.cwd())), ".boss-chat");
-}
-
 function collectRuntimeDirectories(options = {}) {
   const workspaceRoot = getWorkspaceRoot(options);
   const stateHome = getStateHome();
-  const bossChatRoot = getBossChatDataDir(workspaceRoot);
+  const runtime = resolveBossChatRuntimeLayout(workspaceRoot);
+  const bossChatRoot = runtime.data_dir;
   const recommendRuntimeDirs = [
     stateHome,
     path.join(stateHome, "runs")
   ];
-  const bossChatRuntimeDirs = [
-    bossChatRoot,
-    path.join(bossChatRoot, "logs"),
-    path.join(bossChatRoot, "runs"),
-    path.join(bossChatRoot, "profiles"),
-    path.join(bossChatRoot, "reports"),
-    path.join(bossChatRoot, "artifacts")
-  ];
+  const bossChatRuntimeDirs = runtime.directories || [bossChatRoot];
   return {
     workspaceRoot,
     stateHome,
     bossChatRoot,
+    legacyBossChatRoot: runtime.legacy_workspace_dir,
+    migrationPending: runtime.migration_pending,
     directories: dedupePaths([
       ...recommendRuntimeDirs,
       ...bossChatRuntimeDirs
@@ -774,19 +768,20 @@ function collectRuntimeDirectories(options = {}) {
 }
 
 function ensureRuntimeDirectories(options = {}) {
-  const { workspaceRoot, stateHome, bossChatRoot, directories } = collectRuntimeDirectories(options);
-  const created = [];
-  const existed = [];
-  const failed = [];
+  const { workspaceRoot, stateHome } = collectRuntimeDirectories(options);
+  const runtime = ensureBossChatRuntimeReady(workspaceRoot);
+  const recommendCreated = [];
+  const recommendExisted = [];
+  const failed = [...runtime.failed];
 
-  for (const directory of directories) {
+  for (const directory of [stateHome, path.join(stateHome, "runs")]) {
     try {
       const existedBefore = fs.existsSync(directory);
       ensureDir(directory);
       if (existedBefore) {
-        existed.push(directory);
+        recommendExisted.push(directory);
       } else {
-        created.push(directory);
+        recommendCreated.push(directory);
       }
     } catch (error) {
       failed.push({
@@ -799,9 +794,12 @@ function ensureRuntimeDirectories(options = {}) {
   return {
     workspaceRoot,
     stateHome,
-    bossChatRoot,
-    created,
-    existed,
+    bossChatRoot: runtime.data_dir,
+    legacyBossChatRoot: runtime.legacy_workspace_dir,
+    migrationPending: runtime.migration_pending,
+    migration: runtime.migration,
+    created: dedupePaths([...recommendCreated, ...runtime.created]),
+    existed: dedupePaths([...recommendExisted, ...runtime.existed]),
     failed
   };
 }
@@ -1343,10 +1341,13 @@ function printPaths() {
   const codexHome = getCodexHome();
   const stateHome = getStateHome();
   const calibrationResolution = getFeaturedCalibrationResolution(process.cwd());
+  const bossChatRuntime = resolveBossChatRuntimeLayout(getWorkspaceRoot({}));
   console.log(`package_root=${packageRoot}`);
   console.log(`skill_sources=${bundledSkillNames.map((name) => getSkillSourceDir(name)).join(" | ")}`);
   console.log(`codex_home=${codexHome}`);
   console.log(`state_home=${stateHome}`);
+  console.log(`boss_chat_runtime=${bossChatRuntime.data_dir}`);
+  console.log(`boss_chat_legacy_workspace_runtime=${bossChatRuntime.legacy_workspace_dir || ""}`);
   console.log(`skill_targets=${bundledSkillNames.map((name) => path.join(codexHome, "skills", name)).join(" | ")}`);
   console.log(`config_target=${getUserConfigPath()}`);
   console.log(`legacy_config_target=${getLegacyUserConfigPath()}`);
@@ -1408,6 +1409,9 @@ function installAll(options = {}) {
   );
   console.log(`- recommend runtime: ${runtimeDirsResult.stateHome}`);
   console.log(`- boss-chat runtime: ${runtimeDirsResult.bossChatRoot}`);
+  if (runtimeDirsResult.migration?.performed) {
+    console.log(`- boss-chat migration: ${runtimeDirsResult.migration.message}`);
+  }
   if (runtimeDirsResult.failed.length > 0) {
     for (const item of runtimeDirsResult.failed) {
       console.warn(`Runtime dir warning: ${item.path} -> ${item.message}`);
@@ -1628,6 +1632,9 @@ export async function runCli(argv = process.argv) {
       );
       console.log(`- recommend runtime: ${runtimeDirsResult.stateHome}`);
       console.log(`- boss-chat runtime: ${runtimeDirsResult.bossChatRoot}`);
+      if (runtimeDirsResult.migration?.performed) {
+        console.log(`- boss-chat migration: ${runtimeDirsResult.migration.message}`);
+      }
       if (runtimeDirsResult.failed.length > 0) {
         for (const item of runtimeDirsResult.failed) {
           console.warn(`Runtime dir warning: ${item.path} -> ${item.message}`);
@@ -1716,12 +1723,15 @@ export const __testables = {
   buildBossChatCliInput,
   buildDefaultMcpArgs,
   buildMcpLaunchConfig,
+  collectRuntimeDirectories,
+  ensureBossChatRuntimeReady,
+  ensureRuntimeDirectories,
   getBossChatCliRunTarget,
   getDefaultMcpPackageSpecifier,
   getRunFollowUp,
   installSkill,
   isInstalledPackageRoot,
-  ensureRuntimeDirectories,
+  resolveBossChatRuntimeLayout,
   runBossChatCliCommand,
   runPipelineOnce
 };

package/src/test-boss-chat.js

@@ -4,16 +4,18 @@ import os from "node:os";
 import path from "node:path";
 import { mkdir } from "node:fs/promises";
 
-import {
-  cancelBossChatRun,
-  getBossChatHealthCheck,
-  getBossChatRun,
-  pauseBossChatRun,
-  prepareBossChatRun,
-  resumeBossChatRun,
-  startBossChatRun
-} from "./boss-chat.js";
-import { __testables as cliTestables } from "./cli.js";
+import {
+  cancelBossChatRun,
+  ensureBossChatRuntimeReady,
+  getBossChatHealthCheck,
+  getBossChatRun,
+  pauseBossChatRun,
+  prepareBossChatRun,
+  resolveBossChatRuntimeLayout,
+  resumeBossChatRun,
+  startBossChatRun
+} from "./boss-chat.js";
+import { __testables as cliTestables, runCli } from "./cli.js";
 import { __testables as indexTestables } from "./index.js";
 import { BossChatApp } from "../vendor/boss-chat-cli/src/app.js";
 import { __testables as vendorCliTestables } from "../vendor/boss-chat-cli/src/cli.js";
@@ -56,8 +58,8 @@ async function callTool(workspaceRoot, name, args = {}, id = 1) {
   return response?.result?.structuredContent;
 }
 
-function createBossChatTestWorkspace() {
-  const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-boss-chat-"));
+function createBossChatTestWorkspace() {
+  const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-boss-chat-"));
   const configDir = path.join(workspaceRoot, "config");
   const cliDir = path.join(workspaceRoot, "boss-chat-cli", "src");
   fs.mkdirSync(configDir, { recursive: true });
@@ -72,26 +74,13 @@ function createBossChatTestWorkspace() {
     debugPort: 9666
   }, null, 2));
 
-  fs.writeFileSync(path.join(cliDir, "cli.js"), [
-    "#!/usr/bin/env node",
-    "const fs = require('node:fs');",
-    "const path = require('node:path');",
-    "const cwd = process.cwd();",
-    "const statePath = path.join(cwd, '.boss-chat', 'stub-state.json');",
-    "fs.mkdirSync(path.dirname(statePath), { recursive: true });",
-    "const raw = fs.existsSync(statePath) ? fs.readFileSync(statePath, 'utf8') : '{}';",
-    "const state = JSON.parse(raw || '{}');",
-    "state.counter = Number.isInteger(state.counter) ? state.counter : 0;",
-    "state.prepare_calls = Number.isInteger(state.prepare_calls) ? state.prepare_calls : 0;",
-    "if (!Number.isInteger(state.prepare_fail_budget)) {",
-    "  const configured = Number.parseInt(process.env.BOSS_CHAT_STUB_PREPARE_FAILS || '0', 10);",
-    "  state.prepare_fail_budget = Number.isFinite(configured) && configured > 0 ? configured : 0;",
-    "}",
-    "state.runs = state.runs && typeof state.runs === 'object' ? state.runs : {};",
-    "state.get_calls = state.get_calls && typeof state.get_calls === 'object' ? state.get_calls : {};",
-    "const argv = process.argv.slice(2);",
-    "const command = String(argv[0] || '').trim();",
-    "const options = {};",
+  fs.writeFileSync(path.join(cliDir, "cli.js"), [
+    "#!/usr/bin/env node",
+    "const fs = require('node:fs');",
+    "const path = require('node:path');",
+    "const argv = process.argv.slice(2);",
+    "const command = String(argv[0] || '').trim();",
+    "const options = {};",
     "for (let index = 1; index < argv.length; index += 1) {",
     "  const token = String(argv[index] || '');",
     "  if (!token.startsWith('--')) continue;",
@@ -102,11 +91,25 @@ function createBossChatTestWorkspace() {
     "    index += 1;",
     "  } else {",
     "    options[key] = true;",
-    "  }",
-    "}",
-    "function saveAndPrint(payload) {",
-    "  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));",
-    "  process.stdout.write(`${JSON.stringify(payload)}\\n`);",
+    "  }",
+    "}",
+    "const cwd = process.cwd();",
+    "const dataDir = String(options['data-dir'] || process.env.BOSS_CHAT_HOME || path.join(cwd, '.boss-chat'));",
+    "const statePath = path.join(dataDir, 'stub-state.json');",
+    "fs.mkdirSync(path.dirname(statePath), { recursive: true });",
+    "const raw = fs.existsSync(statePath) ? fs.readFileSync(statePath, 'utf8') : '{}';",
+    "const state = JSON.parse(raw || '{}');",
+    "state.counter = Number.isInteger(state.counter) ? state.counter : 0;",
+    "state.prepare_calls = Number.isInteger(state.prepare_calls) ? state.prepare_calls : 0;",
+    "if (!Number.isInteger(state.prepare_fail_budget)) {",
+    "  const configured = Number.parseInt(process.env.BOSS_CHAT_STUB_PREPARE_FAILS || '0', 10);",
+    "  state.prepare_fail_budget = Number.isFinite(configured) && configured > 0 ? configured : 0;",
+    "}",
+    "state.runs = state.runs && typeof state.runs === 'object' ? state.runs : {};",
+    "state.get_calls = state.get_calls && typeof state.get_calls === 'object' ? state.get_calls : {};",
+    "function saveAndPrint(payload) {",
+    "  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));",
+    "  process.stdout.write(`${JSON.stringify(payload)}\\n`);",
     "}",
     "if (command === 'prepare-run') {",
     "  state.prepare_calls += 1;",
@@ -186,29 +189,40 @@ function createBossChatTestWorkspace() {
     "process.exit(1);"
   ].join("\n"), "utf8");
 
-  return workspaceRoot;
-}
-
-function readStubState(workspaceRoot) {
-  const statePath = path.join(workspaceRoot, ".boss-chat", "stub-state.json");
-  return JSON.parse(fs.readFileSync(statePath, "utf8"));
-}
-
-async function withBossChatWorkspace(testFn) {
-  const workspaceRoot = createBossChatTestWorkspace();
-  const previousScreenConfig = process.env.BOSS_RECOMMEND_SCREEN_CONFIG;
-  process.env.BOSS_RECOMMEND_SCREEN_CONFIG = path.join(workspaceRoot, "config", "screening-config.json");
-  try {
-    await testFn(workspaceRoot);
-  } finally {
-    if (previousScreenConfig === undefined) {
-      delete process.env.BOSS_RECOMMEND_SCREEN_CONFIG;
-    } else {
-      process.env.BOSS_RECOMMEND_SCREEN_CONFIG = previousScreenConfig;
-    }
-    fs.rmSync(workspaceRoot, { recursive: true, force: true });
-  }
-}
+  return workspaceRoot;
+}
+
+function getTestChatDataDir(workspaceRoot) {
+  return resolveBossChatRuntimeLayout(workspaceRoot).data_dir;
+}
+
+function readStubState(workspaceRoot) {
+  const statePath = path.join(getTestChatDataDir(workspaceRoot), "stub-state.json");
+  return JSON.parse(fs.readFileSync(statePath, "utf8"));
+}
+
+async function withBossChatWorkspace(testFn) {
+  const workspaceRoot = createBossChatTestWorkspace();
+  const previousScreenConfig = process.env.BOSS_RECOMMEND_SCREEN_CONFIG;
+  const previousBossChatHome = process.env.BOSS_CHAT_HOME;
+  process.env.BOSS_RECOMMEND_SCREEN_CONFIG = path.join(workspaceRoot, "config", "screening-config.json");
+  process.env.BOSS_CHAT_HOME = path.join(workspaceRoot, "user-boss-chat");
+  try {
+    await testFn(workspaceRoot);
+  } finally {
+    if (previousScreenConfig === undefined) {
+      delete process.env.BOSS_RECOMMEND_SCREEN_CONFIG;
+    } else {
+      process.env.BOSS_RECOMMEND_SCREEN_CONFIG = previousScreenConfig;
+    }
+    if (previousBossChatHome === undefined) {
+      delete process.env.BOSS_CHAT_HOME;
+    } else {
+      process.env.BOSS_CHAT_HOME = previousBossChatHome;
+    }
+    fs.rmSync(workspaceRoot, { recursive: true, force: true });
+  }
+}
 
 async function captureConsoleLogs(fn) {
   const messages = [];
@@ -224,12 +238,16 @@ async function captureConsoleLogs(fn) {
   return messages;
 }
 
-async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const health = getBossChatHealthCheck(workspaceRoot);
-    assert.equal(health.status, "OK");
-    assert.equal(health.shared_llm_config, true);
-    assert.equal(health.debug_port, 9666);
+async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
+  await withBossChatWorkspace(async (workspaceRoot) => {
+    const health = getBossChatHealthCheck(workspaceRoot);
+    assert.equal(health.status, "OK");
+    assert.equal(health.shared_llm_config, true);
+    assert.equal(health.debug_port, 9666);
+    assert.equal(health.data_dir_source, "env:BOSS_CHAT_HOME");
+    assert.equal(health.data_dir, getTestChatDataDir(workspaceRoot));
+    assert.equal(health.legacy_workspace_dir, path.join(workspaceRoot, ".boss-chat"));
+    assert.equal(health.migration_pending, false);
 
     const prepared = await prepareBossChatRun({
       workspaceRoot,
@@ -259,9 +277,10 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     assert.equal(preflightTargetQuestion.recommended_argument_patch.target_count, "all");
     assert.equal(Array.isArray(preflightTargetQuestion.options), true);
 
-    const stateAfterPrepare = readStubState(workspaceRoot);
-    assert.equal(stateAfterPrepare.last_prepare_args.profile, "default");
-    assert.equal(stateAfterPrepare.last_prepare_args.port, "9666");
+    const stateAfterPrepare = readStubState(workspaceRoot);
+    assert.equal(stateAfterPrepare.last_prepare_args.profile, "default");
+    assert.equal(stateAfterPrepare.last_prepare_args["data-dir"], getTestChatDataDir(workspaceRoot));
+    assert.equal(stateAfterPrepare.last_prepare_args.port, "9666");
     assert.equal(stateAfterPrepare.last_prepare_args.baseurl, "https://api.example.com/v1");
     assert.equal(stateAfterPrepare.last_prepare_args.apikey, "sk-test-key");
     assert.equal(stateAfterPrepare.last_prepare_args.model, "gpt-4.1-mini");
@@ -281,9 +300,10 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     assert.equal(started.status, "ACCEPTED");
     assert.equal(Boolean(started.run_id), true);
 
-    const stateAfterStart = readStubState(workspaceRoot);
-    assert.equal(stateAfterStart.last_start_args.profile, "default");
-    assert.equal(stateAfterStart.last_start_args.job, "算法工程师");
+    const stateAfterStart = readStubState(workspaceRoot);
+    assert.equal(stateAfterStart.last_start_args.profile, "default");
+    assert.equal(stateAfterStart.last_start_args["data-dir"], getTestChatDataDir(workspaceRoot));
+    assert.equal(stateAfterStart.last_start_args.job, "算法工程师");
     assert.equal(stateAfterStart.last_start_args["start-from"], "unread");
     assert.equal(stateAfterStart.last_start_args.criteria, "有 AI Agent 经验");
     assert.equal(stateAfterStart.last_start_args.targetCount, "2");
@@ -389,11 +409,99 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
       }
     });
     assert.equal(canceled.run.state, "canceled");
-  });
-}
-
-async function testBossChatPrepareShouldRetryWhenChatPageIsNotReady() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
+  });
+}
+
+async function testBossChatRuntimeShouldMigrateLegacyWorkspaceDataOnce() {
+  await withBossChatWorkspace(async (workspaceRoot) => {
+    const legacyDir = path.join(workspaceRoot, ".boss-chat");
+    const legacyStatePath = path.join(legacyDir, "state", "default.json");
+    const legacyRunPath = path.join(legacyDir, "runs", "legacy-run.json");
+    fs.mkdirSync(path.dirname(legacyStatePath), { recursive: true });
+    fs.mkdirSync(path.dirname(legacyRunPath), { recursive: true });
+    fs.writeFileSync(legacyStatePath, JSON.stringify({ cursor: 7 }, null, 2));
+    fs.writeFileSync(legacyRunPath, JSON.stringify({ run_id: "legacy-run" }, null, 2));
+
+    const before = resolveBossChatRuntimeLayout(workspaceRoot);
+    assert.equal(before.data_dir, getTestChatDataDir(workspaceRoot));
+    assert.equal(before.legacy_workspace_dir, legacyDir);
+    assert.equal(before.migration_source_dir, legacyDir);
+    assert.equal(before.migration_pending, true);
+
+    const ready = ensureBossChatRuntimeReady(workspaceRoot);
+    assert.equal(ready.migration.attempted, true);
+    assert.equal(ready.migration.performed, true);
+    assert.equal(fs.existsSync(path.join(ready.data_dir, "state", "default.json")), true);
+    assert.equal(fs.existsSync(path.join(ready.data_dir, "runs", "legacy-run.json")), true);
+    assert.deepEqual(
+      JSON.parse(fs.readFileSync(path.join(ready.data_dir, "state", "default.json"), "utf8")),
+      { cursor: 7 }
+    );
+    assert.equal(fs.existsSync(legacyStatePath), true);
+
+    const after = resolveBossChatRuntimeLayout(workspaceRoot);
+    assert.equal(after.migration_pending, false);
+    assert.equal(after.migration_source_dir, null);
+
+    const secondReady = ensureBossChatRuntimeReady(workspaceRoot);
+    assert.equal(secondReady.migration.attempted, false);
+    assert.equal(secondReady.migration.performed, false);
+  });
+}
+
+function testBossChatRuntimeShouldResolveUserDirForRootWorkspace() {
+  const previousBossChatHome = process.env.BOSS_CHAT_HOME;
+  const previousRecommendHome = process.env.BOSS_RECOMMEND_HOME;
+  const runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "boss-chat-root-runtime-"));
+  try {
+    delete process.env.BOSS_CHAT_HOME;
+    process.env.BOSS_RECOMMEND_HOME = runtimeRoot;
+    const rootWorkspace = path.parse(process.cwd()).root;
+    const runtime = resolveBossChatRuntimeLayout(rootWorkspace);
+    assert.equal(runtime.data_dir, path.join(runtimeRoot, "boss-chat"));
+    assert.equal(runtime.legacy_workspace_dir, null);
+    assert.equal(runtime.migration_pending, false);
+
+    const ready = ensureBossChatRuntimeReady(rootWorkspace);
+    assert.equal(fs.existsSync(ready.data_dir), true);
+    assert.equal(fs.existsSync(path.join(ready.data_dir, "runs")), true);
+  } finally {
+    if (previousBossChatHome === undefined) {
+      delete process.env.BOSS_CHAT_HOME;
+    } else {
+      process.env.BOSS_CHAT_HOME = previousBossChatHome;
+    }
+    if (previousRecommendHome === undefined) {
+      delete process.env.BOSS_RECOMMEND_HOME;
+    } else {
+      process.env.BOSS_RECOMMEND_HOME = previousRecommendHome;
+    }
+    fs.rmSync(runtimeRoot, { recursive: true, force: true });
+  }
+}
+
+async function testBossChatWhereShouldPrintUserRuntimePath() {
+  await withBossChatWorkspace(async (workspaceRoot) => {
+    const previousWorkspaceRoot = process.env.BOSS_WORKSPACE_ROOT;
+    process.env.BOSS_WORKSPACE_ROOT = workspaceRoot;
+    try {
+      const logs = await captureConsoleLogs(async () => {
+        await runCli(["node", "src/cli.js", "where"]);
+      });
+      assert.equal(logs.some((line) => line.includes(`boss_chat_runtime=${getTestChatDataDir(workspaceRoot)}`)), true);
+      assert.equal(logs.some((line) => line.includes(`boss_chat_legacy_workspace_runtime=${path.join(workspaceRoot, ".boss-chat")}`)), true);
+    } finally {
+      if (previousWorkspaceRoot === undefined) {
+        delete process.env.BOSS_WORKSPACE_ROOT;
+      } else {
+        process.env.BOSS_WORKSPACE_ROOT = previousWorkspaceRoot;
+      }
+    }
+  });
+}
+
+async function testBossChatPrepareShouldRetryWhenChatPageIsNotReady() {
+  await withBossChatWorkspace(async (workspaceRoot) => {
     const previousPrepareFails = process.env.BOSS_CHAT_STUB_PREPARE_FAILS;
     process.env.BOSS_CHAT_STUB_PREPARE_FAILS = "2";
     try {
@@ -412,8 +520,53 @@ async function testBossChatPrepareShouldRetryWhenChatPageIsNotReady() {
         process.env.BOSS_CHAT_STUB_PREPARE_FAILS = previousPrepareFails;
       }
     }
-  });
-}
+  });
+}
+
+function testVendorBossChatCliShouldResolveExplicitDataDir() {
+  const cwd = path.join(path.parse(process.cwd()).root, "workspace");
+  const args = vendorCliTestables.parseArgs(["start-run", "--data-dir", "/tmp/boss-chat-data"]);
+  assert.equal(args.dataDir, "/tmp/boss-chat-data");
+  const explicitResolved = vendorCliTestables.resolveDataDirDetails(args, { BOSS_CHAT_HOME: "/tmp/ignored" }, cwd);
+  assert.equal(explicitResolved.source, "arg:data-dir");
+  assert.equal(explicitResolved.path, path.resolve("/tmp/boss-chat-data"));
+  assert.equal(
+    vendorCliTestables.resolveDataDir(args, { BOSS_CHAT_HOME: "/tmp/ignored" }, cwd),
+    path.resolve("/tmp/boss-chat-data")
+  );
+  const envResolved = vendorCliTestables.resolveDataDirDetails({}, { BOSS_CHAT_HOME: "/tmp/from-env" }, cwd);
+  assert.equal(envResolved.source, "env:BOSS_CHAT_HOME");
+  assert.equal(envResolved.path, path.resolve("/tmp/from-env"));
+  assert.equal(
+    vendorCliTestables.resolveDataDir({}, { BOSS_CHAT_HOME: "/tmp/from-env" }, cwd),
+    path.resolve("/tmp/from-env")
+  );
+  const defaultResolved = vendorCliTestables.resolveDataDirDetails({}, {}, cwd);
+  assert.equal(defaultResolved.source, "default:user_home");
+  assert.equal(defaultResolved.path, path.join(os.homedir(), ".boss-recommend-mcp", "boss-chat"));
+  assert.equal(
+    vendorCliTestables.resolveDataDir({}, {}, cwd),
+    path.join(os.homedir(), ".boss-recommend-mcp", "boss-chat")
+  );
+
+  const unsafeRoot = vendorCliTestables.validateDataDir(path.parse(process.cwd()).root);
+  assert.equal(unsafeRoot.ok, false);
+  assert.equal(unsafeRoot.code, "UNSAFE_DATA_DIR");
+  assert.equal(unsafeRoot.message.includes("Refusing unsafe boss-chat data dir"), true);
+
+  const safePath = vendorCliTestables.validateDataDir(path.join(os.homedir(), ".boss-recommend-mcp", "boss-chat"));
+  assert.equal(safePath.ok, true);
+}
+
+function testVendorBossChatCliShouldUseRecommendHomeForDefaultDataDir() {
+  const resolved = vendorCliTestables.resolveDataDirDetails(
+    {},
+    { BOSS_RECOMMEND_HOME: "/tmp/recommend-home" },
+    path.join(path.parse(process.cwd()).root, "workspace")
+  );
+  assert.equal(resolved.source, "default:env:BOSS_RECOMMEND_HOME");
+  assert.equal(resolved.path, path.resolve("/tmp/recommend-home/boss-chat"));
+}
 
 async function testBossChatPageShouldTreatBlankChatShellAsOnChatPage() {
   const fakeChromeClient = {
@@ -2879,9 +3032,12 @@ async function testBossChatReportStoreShouldWriteReadableMarkdownAndCsv() {
   assert.match(csvContent, /先看项目经历，再看实习时长/);
 }
 
-async function main() {
-  await testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli();
-  await testBossChatPrepareShouldRetryWhenChatPageIsNotReady();
+async function main() {
+  await testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli();
+  await testBossChatRuntimeShouldMigrateLegacyWorkspaceDataOnce();
+  testBossChatRuntimeShouldResolveUserDirForRootWorkspace();
+  await testBossChatWhereShouldPrintUserRuntimePath();
+  await testBossChatPrepareShouldRetryWhenChatPageIsNotReady();
   await testBossChatPageShouldTreatBlankChatShellAsOnChatPage();
   await testBossChatRecoverToChatIndexShouldForceNavigateAndWaitForCompleteLoad();
   await testBossChatPageShouldFallbackToEscapeWhenClosingCandidateDetail();
@@ -2889,8 +3045,10 @@ async function main() {
   await testBossChatPageShouldWaitForPanelsClosedInStrictConversationReady();
   await testBossChatPageShouldSurfaceCandidateDetailOverlayAndContentState();
   await testBossChatMcpToolsShouldValidateAndRoute();
-  await testBossChatCliShouldSupportRunAndFollowUpParsing();
-  await testVendorBossChatCliShouldWaitForHydratedChatShell();
+  await testBossChatCliShouldSupportRunAndFollowUpParsing();
+  testVendorBossChatCliShouldResolveExplicitDataDir();
+  testVendorBossChatCliShouldUseRecommendHomeForDefaultDataDir();
+  await testVendorBossChatCliShouldWaitForHydratedChatShell();
   await testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile();
   testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig();
   testVendorBossChatCliShouldParseSharedLlmTransportArgs();