syntaur 0.1.0 → 0.1.2

package/dist/index.js

@@ -83,6 +83,31 @@ var init_fs = __esm({
   }
 });
 
+// src/templates/config.ts
+function renderConfig(params) {
+  return `---
+version: "1.0"
+defaultMissionDir: ${params.defaultMissionDir}
+agentDefaults:
+  trustLevel: medium
+  autoApprove: false
+sync:
+  enabled: false
+  endpoint: null
+  interval: 300
+---
+
+# Syntaur Configuration
+
+Global configuration for the Syntaur CLI.
+`;
+}
+var init_config = __esm({
+  "src/templates/config.ts"() {
+    "use strict";
+  }
+});
+
 // src/dashboard/parser.ts
 function extractFrontmatter(fileContent) {
   const match = fileContent.match(/^---\n([\s\S]*?)\n---/);
@@ -469,6 +494,58 @@ function serializeStatusConfig(statuses) {
   }
   return lines.join("\n");
 }
+function serializeIntegrationConfig(integrations) {
+  const lines = [];
+  if (integrations.claudePluginDir) {
+    lines.push(`  claudePluginDir: ${integrations.claudePluginDir}`);
+  }
+  if (integrations.codexPluginDir) {
+    lines.push(`  codexPluginDir: ${integrations.codexPluginDir}`);
+  }
+  if (integrations.codexMarketplacePath) {
+    lines.push(`  codexMarketplacePath: ${integrations.codexMarketplacePath}`);
+  }
+  if (lines.length === 0) {
+    return null;
+  }
+  return ["integrations:", ...lines].join("\n");
+}
+function stripTopLevelBlock(fmBlock, key) {
+  const blockStart = fmBlock.match(new RegExp(`^${key}:\\s*$`, "m"));
+  if (!blockStart) {
+    return fmBlock.replace(/\n+$/, "");
+  }
+  const startIdx = fmBlock.indexOf(blockStart[0]);
+  const before = fmBlock.slice(0, startIdx);
+  const after = fmBlock.slice(startIdx + blockStart[0].length);
+  const remaining = after.split("\n");
+  let endIdx = 0;
+  for (let i = 0; i < remaining.length; i++) {
+    const line = remaining[i];
+    if (line.trim() === "") {
+      endIdx = i + 1;
+      continue;
+    }
+    if (line.length > 0 && line[0] !== " ") {
+      break;
+    }
+    endIdx = i + 1;
+  }
+  return (before + remaining.slice(endIdx).join("\n")).replace(/\n+$/, "");
+}
+function parseOptionalAbsolutePath(value, fieldName) {
+  if (!value) {
+    return null;
+  }
+  const expanded = expandHome(String(value));
+  if (!isAbsolute(expanded)) {
+    console.warn(
+      `Warning: config.md ${fieldName} is not an absolute path ("${value}"), ignoring it`
+    );
+    return null;
+  }
+  return resolve4(expanded);
+}
 async function writeStatusConfig(statuses) {
   const configPath = resolve4(syntaurRoot(), "config.md");
   const statusBlock = serializeStatusConfig(statuses);
@@ -531,28 +608,42 @@ async function deleteStatusConfig() {
   if (!fmMatch) return;
   const fmBlock = fmMatch[2];
   const afterFrontmatter = existing.slice(fmMatch[0].length);
-  const statusesStart = fmBlock.match(/^statuses:\s*$/m);
-  if (!statusesStart) return;
-  const startIdx = fmBlock.indexOf(statusesStart[0]);
-  const before = fmBlock.slice(0, startIdx);
-  const after = fmBlock.slice(startIdx + statusesStart[0].length);
-  const remaining = after.split("\n");
-  let endIdx = 0;
-  for (let i = 0; i < remaining.length; i++) {
-    const line = remaining[i];
-    if (line.trim() === "") {
-      endIdx = i + 1;
-      continue;
-    }
-    if (line.length > 0 && line[0] !== " ") break;
-    endIdx = i + 1;
-  }
-  const cleanedFm = (before + remaining.slice(endIdx).join("\n")).replace(/\n+$/, "");
+  const cleanedFm = stripTopLevelBlock(fmBlock, "statuses");
   const newContent = `---
 ${cleanedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath, newContent);
 }
+async function updateIntegrationConfig(integrations) {
+  const configPath = resolve4(syntaurRoot(), "config.md");
+  const nextIntegrations = {
+    ...(await readConfig()).integrations,
+    ...integrations
+  };
+  const integrationBlock = serializeIntegrationConfig(nextIntegrations);
+  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultMissionDir: defaultMissionDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "1.0"
+defaultMissionDir: ${defaultMissionDir()}
+${integrationBlock ?? ""}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "integrations");
+  const newFm = integrationBlock ? `${cleanedFm}
+${integrationBlock}`.replace(/^\n+/, "") : cleanedFm;
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 async function readConfig() {
   const configPath = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
@@ -578,15 +669,30 @@ async function readConfig() {
       trustLevel: fm["agentDefaults.trustLevel"] || DEFAULT_CONFIG.agentDefaults.trustLevel,
       autoApprove: fm["agentDefaults.autoApprove"] === "true" || DEFAULT_CONFIG.agentDefaults.autoApprove
     },
+    integrations: {
+      claudePluginDir: parseOptionalAbsolutePath(
+        fm["integrations.claudePluginDir"],
+        "integrations.claudePluginDir"
+      ),
+      codexPluginDir: parseOptionalAbsolutePath(
+        fm["integrations.codexPluginDir"],
+        "integrations.codexPluginDir"
+      ),
+      codexMarketplacePath: parseOptionalAbsolutePath(
+        fm["integrations.codexMarketplacePath"],
+        "integrations.codexMarketplacePath"
+      )
+    },
     statuses: parseStatusConfig(content)
   };
 }
 var DEFAULT_CONFIG;
-var init_config = __esm({
+var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
     init_paths();
     init_fs();
+    init_config();
     DEFAULT_CONFIG = {
       version: "1.0",
       defaultMissionDir: defaultMissionDir(),
@@ -594,6 +700,11 @@ var init_config = __esm({
         trustLevel: "medium",
         autoApprove: false
       },
+      integrations: {
+        claudePluginDir: null,
+        codexPluginDir: null,
+        codexMarketplacePath: null
+      },
       statuses: null
     };
   }
@@ -1222,13 +1333,13 @@ var init_help = __esm({
       // --- Plugin & adapter setup (indices 13-16) ---
       {
         command: "syntaur install-plugin",
-        description: "Install the Syntaur Claude Code plugin into your home plugin directory.",
-        example: "syntaur install-plugin"
+        description: "Install the Syntaur Claude Code plugin, detecting the local Claude marketplace when available and prompting for the target directory when interactive.",
+        example: "syntaur install-plugin --target-dir ~/.claude/plugins/marketplaces/user-plugins/plugins/syntaur"
       },
       {
         command: "syntaur install-codex-plugin",
-        description: "Install the Syntaur Codex plugin and register its local marketplace entry.",
-        example: "syntaur install-codex-plugin"
+        description: "Install the Syntaur Codex plugin and register its marketplace entry, prompting for both paths when interactive.",
+        example: "syntaur install-codex-plugin --target-dir ~/plugins/syntaur --marketplace-path ~/.agents/plugins/marketplace.json"
       },
       {
         command: "syntaur uninstall",
@@ -2684,7 +2795,7 @@ var init_api = __esm({
     "use strict";
     init_lifecycle();
     init_fs();
-    init_config();
+    init_config2();
     init_parser();
     init_help();
     STALE_ASSIGNMENT_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -3606,30 +3717,11 @@ import { Command as Command2 } from "commander";
 // src/commands/init.ts
 init_paths();
 init_fs();
+init_config();
 import { resolve as resolve3, dirname as dirname2 } from "path";
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
 import { fileURLToPath } from "url";
 
-// src/templates/config.ts
-function renderConfig(params) {
-  return `---
-version: "1.0"
-defaultMissionDir: ${params.defaultMissionDir}
-agentDefaults:
-  trustLevel: medium
-  autoApprove: false
-sync:
-  enabled: false
-  endpoint: null
-  interval: 300
----
-
-# Syntaur Configuration
-
-Global configuration for the Syntaur CLI.
-`;
-}
-
 // src/utils/playbooks.ts
 init_fs();
 init_parser();
@@ -3752,6 +3844,9 @@ function generateId() {
 // src/commands/create-mission.ts
 init_paths();
 init_fs();
+init_config2();
+
+// src/templates/index.ts
 init_config();
 
 // src/templates/manifest.ts
@@ -4527,7 +4622,7 @@ import { resolve as resolve6 } from "path";
 init_timestamp();
 init_paths();
 init_fs();
-init_config();
+init_config2();
 async function createAssignmentCommand(title, options) {
   if (!title.trim()) {
     throw new Error("Assignment title cannot be empty.");
@@ -4676,7 +4771,7 @@ Use --slug to specify a different slug.`
 }
 
 // src/commands/dashboard.ts
-init_config();
+init_config2();
 import { spawn } from "child_process";
 import { resolve as resolve18, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -4836,7 +4931,7 @@ function createWatcher(options) {
 
 // src/dashboard/server.ts
 init_fs();
-init_config();
+init_config2();
 
 // src/dashboard/api-write.ts
 init_lifecycle();
@@ -7212,7 +7307,7 @@ async function dashboardCommand(options) {
 // src/commands/assign.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve19 } from "path";
 init_lifecycle();
 async function assignCommand(assignment, options) {
@@ -7251,7 +7346,7 @@ async function assignCommand(assignment, options) {
 // src/commands/start.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve20 } from "path";
 init_lifecycle();
 async function startCommand(assignment, options) {
@@ -7294,7 +7389,7 @@ async function startCommand(assignment, options) {
 // src/commands/complete.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve21 } from "path";
 init_lifecycle();
 async function completeCommand(assignment, options) {
@@ -7330,7 +7425,7 @@ async function completeCommand(assignment, options) {
 // src/commands/block.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve22 } from "path";
 init_lifecycle();
 async function blockCommand(assignment, options) {
@@ -7368,7 +7463,7 @@ async function blockCommand(assignment, options) {
 // src/commands/unblock.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve23 } from "path";
 init_lifecycle();
 async function unblockCommand(assignment, options) {
@@ -7404,7 +7499,7 @@ async function unblockCommand(assignment, options) {
 // src/commands/review.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve24 } from "path";
 init_lifecycle();
 async function reviewCommand(assignment, options) {
@@ -7440,7 +7535,7 @@ async function reviewCommand(assignment, options) {
 // src/commands/fail.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve25 } from "path";
 init_lifecycle();
 async function failCommand(assignment, options) {
@@ -7476,7 +7571,7 @@ async function failCommand(assignment, options) {
 // src/commands/reopen.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve26 } from "path";
 init_lifecycle();
 async function reopenCommand(assignment, options) {
@@ -7509,10 +7604,15 @@ async function reopenCommand(assignment, options) {
   console.log(result.message);
 }
 
+// src/commands/install-plugin.ts
+init_config2();
+
 // src/utils/install.ts
+init_config2();
 init_fs();
 import {
   cp,
+  readdir as readdir8,
   symlink,
   lstat,
   readFile as readFile12,
@@ -7523,7 +7623,7 @@ import {
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename, dirname as dirname7, resolve as resolve28 } from "path";
+import { basename, dirname as dirname7, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve28 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
@@ -7555,10 +7655,22 @@ function getPluginRelativePath(pluginKind) {
 function getPluginManifestRelativePath(pluginKind) {
   return pluginKind === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json";
 }
-function getPluginTargetDir(pluginKind) {
+function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir3();
   return pluginKind === "claude" ? resolve28(home, ".claude", "plugins", "syntaur") : resolve28(home, "plugins", "syntaur");
 }
+function getDefaultMarketplacePath() {
+  return resolve28(homedir3(), ".agents", "plugins", "marketplace.json");
+}
+function getClaudeMarketplacesRoot() {
+  return resolve28(homedir3(), ".claude", "plugins", "marketplaces");
+}
+function getClaudeKnownMarketplacesPath() {
+  return resolve28(homedir3(), ".claude", "plugins", "known_marketplaces.json");
+}
+function getClaudeInstalledPluginsPath() {
+  return resolve28(homedir3(), ".claude", "plugins", "installed_plugins.json");
+}
 function getInstallMarkerPath(targetDir) {
   return resolve28(targetDir, INSTALL_MARKER_FILENAME);
 }
@@ -7566,6 +7678,22 @@ async function readPackageManifest(packageRoot2) {
   const raw = await readFile12(resolve28(packageRoot2, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
+async function readJsonFileIfExists(pathValue) {
+  if (!await fileExists(pathValue)) {
+    return null;
+  }
+  try {
+    const raw = await readFile12(pathValue, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function readClaudePluginManifest(pluginDir) {
+  return await readJsonFileIfExists(
+    resolve28(pluginDir, ".claude-plugin", "plugin.json")
+  ) ?? {};
+}
 async function readPluginManifestName(targetDir, pluginKind) {
   const manifestPath = resolve28(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
@@ -7649,22 +7777,325 @@ async function removeInstallMarker(targetDir) {
     });
   }
 }
-async function resolvePluginPaths(pluginKind) {
+function normalizeAbsoluteInstallPath(pathValue, label) {
+  const expanded = expandHome(pathValue.trim());
+  if (!isAbsolute2(expanded)) {
+    throw new Error(`${label} must be an absolute path.`);
+  }
+  return resolve28(expanded);
+}
+async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot2 = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot: packageRoot2,
     sourceDir: resolve28(packageRoot2, getPluginRelativePath(pluginKind)),
-    targetDir: getPluginTargetDir(pluginKind)
+    targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
-async function installManagedPlugin(options) {
-  const { pluginKind, force = false, link = false } = options;
-  const paths = await resolvePluginPaths(pluginKind);
-  if (!await fileExists(paths.sourceDir)) {
+async function readInstalledClaudeMarketplaceNames() {
+  const parsed = await readJsonFileIfExists(getClaudeInstalledPluginsPath());
+  const names = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(parsed?.plugins ?? {})) {
+    const atIndex = key.lastIndexOf("@");
+    if (atIndex > 0 && atIndex < key.length - 1) {
+      names.add(key.slice(atIndex + 1));
+    }
+  }
+  return names;
+}
+async function readKnownClaudeMarketplaceRecords() {
+  const parsed = await readJsonFileIfExists(
+    getClaudeKnownMarketplacesPath()
+  );
+  return new Map(Object.entries(parsed ?? {}));
+}
+async function readClaudeMarketplaceFile(manifestPath) {
+  const parsed = await readJsonFileIfExists(manifestPath);
+  if (!parsed || typeof parsed !== "object") {
+    return { plugins: [] };
+  }
+  return {
+    ...parsed,
+    plugins: Array.isArray(parsed.plugins) ? parsed.plugins.filter(
+      (plugin) => typeof plugin === "object" && plugin !== null
+    ) : []
+  };
+}
+async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
+  await ensureDir(dirname7(manifestPath));
+  await writeFile4(manifestPath, `${JSON.stringify(marketplace, null, 2)}
+`, "utf-8");
+}
+function buildClaudeMarketplaceSourcePath(pluginTargetDir, marketplaceRootDir) {
+  const relPath = relative2(marketplaceRootDir, pluginTargetDir).replaceAll("\\", "/");
+  if (relPath === "") {
+    return ".";
+  }
+  return relPath.startsWith(".") ? relPath : `./${relPath}`;
+}
+function normalizeClaudeAuthor(author) {
+  if (!author) {
+    return void 0;
+  }
+  if (typeof author === "string") {
+    return { name: author };
+  }
+  return {
+    name: author.name,
+    email: author.email
+  };
+}
+function buildClaudeMarketplaceEntry(pluginTargetDir, marketplaceRootDir, manifest) {
+  return {
+    name: manifest.name ?? "syntaur",
+    description: manifest.description,
+    version: manifest.version,
+    author: normalizeClaudeAuthor(manifest.author),
+    source: buildClaudeMarketplaceSourcePath(pluginTargetDir, marketplaceRootDir),
+    category: "development"
+  };
+}
+function scoreClaudeMarketplaceCandidate(candidate) {
+  if (candidate.hasSyntaur) {
+    return 100;
+  }
+  if (candidate.active && candidate.isUserPlugins) {
+    return 90;
+  }
+  if (candidate.isUserPlugins) {
+    return 80;
+  }
+  if (candidate.active && candidate.isDirectorySource) {
+    return 70;
+  }
+  if (candidate.isDirectorySource) {
+    return 60;
+  }
+  if (candidate.active) {
+    return 50;
+  }
+  return 10;
+}
+async function listClaudeMarketplaceCandidates() {
+  const rootDir = getClaudeMarketplacesRoot();
+  if (!await fileExists(rootDir)) {
+    return [];
+  }
+  const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
+    readKnownClaudeMarketplaceRecords(),
+    readInstalledClaudeMarketplaceNames(),
+    readdir8(rootDir, { withFileTypes: true })
+  ]);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const candidateRoot = resolve28(rootDir, entry.name);
+    const manifestPath = resolve28(candidateRoot, ".claude-plugin", "marketplace.json");
+    if (!await fileExists(manifestPath)) {
+      continue;
+    }
+    const parsed = await readClaudeMarketplaceFile(manifestPath);
+    const candidateName = typeof parsed.name === "string" && parsed.name.trim() !== "" ? parsed.name : entry.name;
+    const known = knownMarketplaces.get(candidateName);
+    const hasSyntaur = parsed.plugins.some(
+      (plugin) => plugin.name === "syntaur" && typeof plugin.source === "string"
+    );
+    const isUserPlugins = candidateName === "user-plugins" || entry.name === "user-plugins";
+    candidates.push({
+      name: candidateName,
+      rootDir: candidateRoot,
+      manifestPath,
+      active: activeMarketplaceNames.has(candidateName),
+      hasSyntaur,
+      isUserPlugins,
+      isDirectorySource: known?.source?.source === "directory" || isUserPlugins
+    });
+    seen.add(candidateRoot);
+  }
+  for (const [candidateName, known] of knownMarketplaces.entries()) {
+    const installLocation = known.installLocation;
+    if (!installLocation) {
+      continue;
+    }
+    const candidateRoot = resolve28(expandHome(installLocation));
+    if (seen.has(candidateRoot)) {
+      continue;
+    }
+    const manifestPath = resolve28(candidateRoot, ".claude-plugin", "marketplace.json");
+    if (!await fileExists(manifestPath)) {
+      continue;
+    }
+    const parsed = await readClaudeMarketplaceFile(manifestPath);
+    candidates.push({
+      name: typeof parsed.name === "string" && parsed.name.trim() !== "" ? parsed.name : candidateName,
+      rootDir: candidateRoot,
+      manifestPath,
+      active: activeMarketplaceNames.has(candidateName),
+      hasSyntaur: parsed.plugins.some(
+        (plugin) => plugin.name === "syntaur" && typeof plugin.source === "string"
+      ),
+      isUserPlugins: candidateName === "user-plugins",
+      isDirectorySource: known.source?.source === "directory" || candidateName === "user-plugins"
+    });
+  }
+  return candidates.sort((a, b) => scoreClaudeMarketplaceCandidate(b) - scoreClaudeMarketplaceCandidate(a));
+}
+async function getPreferredClaudeMarketplace() {
+  const candidate = (await listClaudeMarketplaceCandidates())[0];
+  if (!candidate) {
+    return null;
+  }
+  return {
+    name: candidate.name,
+    rootDir: candidate.rootDir,
+    manifestPath: candidate.manifestPath,
+    targetDir: resolve28(candidate.rootDir, "plugins", "syntaur")
+  };
+}
+async function detectClaudeMarketplaceForTarget(targetDir) {
+  const normalizedTargetDir = normalizeAbsoluteInstallPath(targetDir, "Claude plugin target");
+  const pluginsDir = dirname7(normalizedTargetDir);
+  if (basename(pluginsDir) !== "plugins") {
+    return null;
+  }
+  const rootDir = dirname7(pluginsDir);
+  const manifestPath = resolve28(rootDir, ".claude-plugin", "marketplace.json");
+  if (!await fileExists(manifestPath)) {
+    return null;
+  }
+  const marketplace = await readClaudeMarketplaceFile(manifestPath);
+  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename(rootDir);
+  return {
+    name,
+    rootDir,
+    manifestPath,
+    targetDir: normalizedTargetDir
+  };
+}
+async function findManagedClaudeMarketplacePluginDir() {
+  const marketplaces = await listClaudeMarketplaceCandidates();
+  for (const marketplace of marketplaces) {
+    const targetDir = resolve28(marketplace.rootDir, "plugins", "syntaur");
+    const status = await getInstallStatus(targetDir, "claude");
+    if (status.exists && status.managed) {
+      return targetDir;
+    }
+  }
+  return null;
+}
+async function ensureClaudeMarketplaceEntry(options) {
+  const marketplaceRootDir = normalizeAbsoluteInstallPath(
+    options.marketplaceRootDir,
+    "Claude marketplace root"
+  );
+  const manifestPath = normalizeAbsoluteInstallPath(
+    options.manifestPath,
+    "Claude marketplace manifest"
+  );
+  const pluginTargetDir = normalizeAbsoluteInstallPath(
+    options.pluginTargetDir,
+    "Claude plugin target"
+  );
+  const marketplace = await readClaudeMarketplaceFile(manifestPath);
+  const pluginManifest = await readClaudePluginManifest(pluginTargetDir);
+  const entry = buildClaudeMarketplaceEntry(pluginTargetDir, marketplaceRootDir, pluginManifest);
+  const expectedSource = entry.source;
+  const existingIndex = marketplace.plugins.findIndex(
+    (plugin) => plugin.name === entry.name && plugin.source === expectedSource
+  );
+  if (existingIndex >= 0) {
+    const existing = marketplace.plugins[existingIndex];
+    const changed = JSON.stringify(existing) !== JSON.stringify(entry);
+    if (changed) {
+      marketplace.plugins[existingIndex] = entry;
+      await writeClaudeMarketplaceFile(manifestPath, marketplace);
+    }
+    return { manifestPath, changed };
+  }
+  const conflictingIndex = marketplace.plugins.findIndex((plugin) => plugin.name === entry.name);
+  if (conflictingIndex >= 0) {
+    const expectedExistingSource = options.expectedExistingPluginTargetDir ? buildClaudeMarketplaceSourcePath(
+      normalizeAbsoluteInstallPath(
+        options.expectedExistingPluginTargetDir,
+        "Existing Claude plugin target"
+      ),
+      marketplaceRootDir
+    ) : null;
+    const existing = marketplace.plugins[conflictingIndex];
+    if (expectedExistingSource && existing.source === expectedExistingSource) {
+      marketplace.plugins[conflictingIndex] = entry;
+      await writeClaudeMarketplaceFile(manifestPath, marketplace);
+      return { manifestPath, changed: true };
+    }
     throw new Error(
-      `Plugin source directory not found at ${paths.sourceDir}.`
+      `Marketplace entry "${entry.name}" already exists with different settings in ${manifestPath}. Remove it manually before installing the Claude plugin.`
     );
   }
+  marketplace.plugins.push(entry);
+  await writeClaudeMarketplaceFile(manifestPath, marketplace);
+  return { manifestPath, changed: true };
+}
+async function removeClaudeMarketplaceEntry(options) {
+  const manifestPath = normalizeAbsoluteInstallPath(
+    options.manifestPath,
+    "Claude marketplace manifest"
+  );
+  if (!await fileExists(manifestPath)) {
+    return { manifestPath, removed: false };
+  }
+  const marketplaceRootDir = normalizeAbsoluteInstallPath(
+    options.marketplaceRootDir,
+    "Claude marketplace root"
+  );
+  const expectedSource = options.pluginTargetDir ? buildClaudeMarketplaceSourcePath(
+    normalizeAbsoluteInstallPath(options.pluginTargetDir, "Claude plugin target"),
+    marketplaceRootDir
+  ) : null;
+  const marketplace = await readClaudeMarketplaceFile(manifestPath);
+  const beforeCount = marketplace.plugins.length;
+  marketplace.plugins = marketplace.plugins.filter((plugin) => {
+    if (plugin.name !== "syntaur") {
+      return true;
+    }
+    if (!expectedSource) {
+      return false;
+    }
+    return plugin.source !== expectedSource;
+  });
+  if (marketplace.plugins.length === beforeCount) {
+    return { manifestPath, removed: false };
+  }
+  await writeClaudeMarketplaceFile(manifestPath, marketplace);
+  return { manifestPath, removed: true };
+}
+async function inspectInstallPath(pluginKind, targetDir) {
+  const normalizedTarget = normalizeAbsoluteInstallPath(targetDir, `${getPluginDisplayName(pluginKind)} target`);
+  const status = await getInstallStatus(normalizedTarget, pluginKind);
+  return {
+    exists: status.exists,
+    managed: status.managed,
+    installMode: status.installMode,
+    targetDir: normalizedTarget
+  };
+}
+async function installManagedPlugin(options) {
+  const {
+    pluginKind,
+    force = false,
+    link = false,
+    targetDir = getDefaultPluginTargetDir(pluginKind)
+  } = options;
+  const normalizedTargetDir = normalizeAbsoluteInstallPath(
+    targetDir,
+    `${getPluginDisplayName(pluginKind)} target`
+  );
+  const paths = await resolvePluginPaths(pluginKind, normalizedTargetDir);
+  if (!await fileExists(paths.sourceDir)) {
+    throw new Error(`Plugin source directory not found at ${paths.sourceDir}.`);
+  }
   const desiredMode = link ? "link" : "copy";
   const existing = await getInstallStatus(paths.targetDir, pluginKind);
   if (existing.exists && !existing.managed) {
@@ -7695,12 +8126,19 @@ async function installManagedPlugin(options) {
     changed: true
   };
 }
-function buildSyntaurMarketplaceEntry() {
+function buildMarketplaceSourcePath(pluginTargetDir, marketplacePath) {
+  const relPath = relative2(dirname7(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
+  if (relPath === "") {
+    return ".";
+  }
+  return relPath.startsWith(".") ? relPath : `./${relPath}`;
+}
+function buildSyntaurMarketplaceEntry(pluginTargetDir, marketplacePath) {
   return {
     name: "syntaur",
     source: {
       source: "local",
-      path: "./plugins/syntaur"
+      path: buildMarketplaceSourcePath(pluginTargetDir, marketplacePath)
     },
     policy: {
       installation: "AVAILABLE",
@@ -7709,11 +8147,7 @@ function buildSyntaurMarketplaceEntry() {
     category: "Coding"
   };
 }
-function getMarketplacePath() {
-  return resolve28(homedir3(), ".agents", "plugins", "marketplace.json");
-}
-async function readMarketplaceFile() {
-  const marketplacePath = getMarketplacePath();
+async function readMarketplaceFile(marketplacePath) {
   if (!await fileExists(marketplacePath)) {
     return {
       name: "local",
@@ -7729,50 +8163,90 @@ async function readMarketplaceFile() {
     plugins: Array.isArray(parsed.plugins) ? parsed.plugins : []
   };
 }
-async function writeMarketplaceFile(marketplace) {
-  const marketplacePath = getMarketplacePath();
+async function writeMarketplaceFile(marketplacePath, marketplace) {
   await ensureDir(dirname7(marketplacePath));
   await writeFile4(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
-async function ensureMarketplaceEntry() {
-  const marketplace = await readMarketplaceFile();
-  const entry = buildSyntaurMarketplaceEntry();
+async function hasAnySyntaurMarketplaceEntry(marketplacePath) {
+  const marketplace = await readMarketplaceFile(marketplacePath);
+  return marketplace.plugins.some(
+    (plugin) => plugin.name === "syntaur" && plugin.source?.source === "local"
+  );
+}
+async function hasSyntaurMarketplaceEntry(marketplacePath, pluginTargetDir) {
+  const marketplace = await readMarketplaceFile(marketplacePath);
+  const expectedPath = buildMarketplaceSourcePath(pluginTargetDir, marketplacePath);
+  return marketplace.plugins.some(
+    (plugin) => plugin.name === "syntaur" && plugin.source?.source === "local" && plugin.source?.path === expectedPath
+  );
+}
+async function ensureMarketplaceEntry(options) {
+  const marketplacePath = normalizeAbsoluteInstallPath(
+    options.marketplacePath,
+    "Codex marketplace path"
+  );
+  const pluginTargetDir = normalizeAbsoluteInstallPath(
+    options.pluginTargetDir,
+    "Codex plugin target"
+  );
+  const marketplace = await readMarketplaceFile(marketplacePath);
+  const entry = buildSyntaurMarketplaceEntry(pluginTargetDir, marketplacePath);
   const existingIndex = marketplace.plugins.findIndex(
     (plugin) => plugin.name === entry.name && plugin.source?.source === entry.source.source && plugin.source?.path === entry.source.path
   );
   if (existingIndex >= 0) {
-    return {
-      marketplacePath: getMarketplacePath(),
-      changed: false
-    };
+    return { marketplacePath, changed: false };
   }
   const conflictingIndex = marketplace.plugins.findIndex((plugin) => plugin.name === entry.name);
   if (conflictingIndex >= 0) {
+    const existing = marketplace.plugins[conflictingIndex];
+    const expectedExistingPath = options.expectedExistingPluginTargetDir ? buildMarketplaceSourcePath(
+      normalizeAbsoluteInstallPath(
+        options.expectedExistingPluginTargetDir,
+        "Existing Codex plugin target"
+      ),
+      marketplacePath
+    ) : null;
+    if (existing.source?.source === "local" && expectedExistingPath && existing.source?.path === expectedExistingPath) {
+      marketplace.plugins[conflictingIndex] = entry;
+      await writeMarketplaceFile(marketplacePath, marketplace);
+      return { marketplacePath, changed: true };
+    }
     throw new Error(
-      `Marketplace entry "${entry.name}" already exists with different settings. Remove it manually before installing the Codex plugin.`
+      `Marketplace entry "${entry.name}" already exists with different settings in ${marketplacePath}. Remove it manually before installing the Codex plugin.`
     );
   }
   marketplace.plugins.push(entry);
-  await writeMarketplaceFile(marketplace);
-  return {
-    marketplacePath: getMarketplacePath(),
-    changed: true
-  };
+  await writeMarketplaceFile(marketplacePath, marketplace);
+  return { marketplacePath, changed: true };
 }
 function isDefaultMarketplaceShell(marketplace) {
   return marketplace.name === "local" && (marketplace.interface?.displayName ?? "Local Plugins") === "Local Plugins";
 }
-async function removeMarketplaceEntry() {
-  const marketplacePath = getMarketplacePath();
+async function removeMarketplaceEntry(options) {
+  const marketplacePath = normalizeAbsoluteInstallPath(
+    options.marketplacePath,
+    "Codex marketplace path"
+  );
   if (!await fileExists(marketplacePath)) {
     return { marketplacePath, removed: false };
   }
-  const marketplace = await readMarketplaceFile();
+  const expectedSourcePath = options.expectedSourcePath ?? (options.pluginTargetDir ? buildMarketplaceSourcePath(
+    normalizeAbsoluteInstallPath(options.pluginTargetDir, "Codex plugin target"),
+    marketplacePath
+  ) : null);
+  const marketplace = await readMarketplaceFile(marketplacePath);
   const beforeCount = marketplace.plugins.length;
-  marketplace.plugins = marketplace.plugins.filter(
-    (plugin) => !(plugin.name === "syntaur" && plugin.source?.source === "local" && plugin.source?.path === "./plugins/syntaur")
-  );
+  marketplace.plugins = marketplace.plugins.filter((plugin) => {
+    if (plugin.name !== "syntaur" || plugin.source?.source !== "local") {
+      return true;
+    }
+    if (!expectedSourcePath) {
+      return false;
+    }
+    return plugin.source.path !== expectedSourcePath;
+  });
   if (marketplace.plugins.length === beforeCount) {
     return { marketplacePath, removed: false };
   }
@@ -7780,23 +8254,66 @@ async function removeMarketplaceEntry() {
     await rm2(marketplacePath, { force: true });
     return { marketplacePath, removed: true };
   }
-  await writeMarketplaceFile(marketplace);
+  await writeMarketplaceFile(marketplacePath, marketplace);
   return { marketplacePath, removed: true };
 }
-async function uninstallManagedPlugin(pluginKind) {
-  const targetDir = getPluginTargetDir(pluginKind);
-  const existing = await getInstallStatus(targetDir, pluginKind);
+async function uninstallManagedPlugin(pluginKind, targetDir = getDefaultPluginTargetDir(pluginKind)) {
+  const normalizedTarget = normalizeAbsoluteInstallPath(
+    targetDir,
+    `${getPluginDisplayName(pluginKind)} target`
+  );
+  const existing = await getInstallStatus(normalizedTarget, pluginKind);
   if (!existing.exists) {
-    return { removed: false, targetDir };
+    return { removed: false, targetDir: normalizedTarget };
   }
   if (!existing.managed) {
     throw new Error(
-      `${targetDir} exists but is not a Syntaur-managed install. Remove it manually if you want to replace it.`
+      `${normalizedTarget} exists but is not a Syntaur-managed install. Remove it manually if you want to replace it.`
     );
   }
-  await removeInstallMarker(targetDir);
-  await rm2(targetDir, { recursive: true, force: true });
-  return { removed: true, targetDir };
+  await removeInstallMarker(normalizedTarget);
+  await rm2(normalizedTarget, { recursive: true, force: true });
+  return { removed: true, targetDir: normalizedTarget };
+}
+async function getConfiguredOrLegacyManagedPluginDir(pluginKind) {
+  const config = await readConfig();
+  const configuredPath = pluginKind === "claude" ? config.integrations.claudePluginDir : config.integrations.codexPluginDir;
+  if (configuredPath) {
+    return configuredPath;
+  }
+  const defaultTarget = getDefaultPluginTargetDir(pluginKind);
+  const status = await getInstallStatus(defaultTarget, pluginKind);
+  if (status.exists && status.managed) {
+    return defaultTarget;
+  }
+  if (pluginKind === "claude") {
+    return findManagedClaudeMarketplacePluginDir();
+  }
+  return null;
+}
+async function getConfiguredOrLegacyMarketplacePath() {
+  const config = await readConfig();
+  if (config.integrations.codexMarketplacePath) {
+    return config.integrations.codexMarketplacePath;
+  }
+  const defaultMarketplacePath = getDefaultMarketplacePath();
+  return await hasAnySyntaurMarketplaceEntry(defaultMarketplacePath) ? defaultMarketplacePath : null;
+}
+async function recommendPluginTargetDir(pluginKind) {
+  const configuredOrManaged = await getConfiguredOrLegacyManagedPluginDir(pluginKind);
+  if (pluginKind !== "claude") {
+    return configuredOrManaged ?? getDefaultPluginTargetDir(pluginKind);
+  }
+  const preferredMarketplace = await getPreferredClaudeMarketplace();
+  const legacyTarget = getDefaultPluginTargetDir("claude");
+  if (configuredOrManaged) {
+    return configuredOrManaged === legacyTarget && preferredMarketplace ? preferredMarketplace.targetDir : configuredOrManaged;
+  }
+  return preferredMarketplace?.targetDir ?? legacyTarget;
+}
+async function recommendMarketplacePath() {
+  const configuredOrManaged = await getConfiguredOrLegacyMarketplacePath();
+  return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
   return fileExists(resolve28(syntaurRoot(), "config.md"));
@@ -7808,52 +8325,224 @@ async function removeSyntaurData() {
   await rm2(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredMissionDir() {
-  const configPath = resolve28(syntaurRoot(), "config.md");
-  if (!await fileExists(configPath)) {
-    return null;
-  }
-  const raw = await readFile12(configPath, "utf-8");
-  const match = raw.match(/^defaultMissionDir:\s*(.+)$/m);
-  if (!match) {
+  if (!await fileExists(resolve28(syntaurRoot(), "config.md"))) {
     return null;
   }
-  return expandHome(match[1].trim().replace(/^["']|["']$/g, ""));
+  return (await readConfig()).defaultMissionDir;
+}
+function getPluginDisplayName(pluginKind) {
+  return pluginKind === "claude" ? "Claude Code plugin" : "Codex plugin";
 }
 function getPluginInstallCommand(pluginKind) {
   return pluginKind === "claude" ? "syntaur install-plugin" : "syntaur install-codex-plugin";
 }
 
+// src/utils/prompt.ts
+import { stdin as input, stdout as output } from "process";
+import { createInterface } from "readline/promises";
+function isInteractiveTerminal() {
+  return Boolean(input.isTTY && output.isTTY);
+}
+async function confirmPrompt(question, defaultValue = false) {
+  if (!isInteractiveTerminal()) {
+    throw new Error("Interactive confirmation requires a TTY.");
+  }
+  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
+    if (answer === "") {
+      return defaultValue;
+    }
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function textPrompt(question, defaultValue) {
+  if (!isInteractiveTerminal()) {
+    throw new Error("Interactive input requires a TTY.");
+  }
+  const suffix = defaultValue !== void 0 ? ` [${defaultValue}] ` : " ";
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`${question}${suffix}`)).trim();
+    if (answer === "" && defaultValue !== void 0) {
+      return defaultValue;
+    }
+    return answer;
+  } finally {
+    rl.close();
+  }
+}
+
 // src/commands/install-plugin.ts
+async function promptForInstallPath(question, recommendedPath) {
+  while (true) {
+    const answer = await textPrompt(question, recommendedPath);
+    try {
+      return normalizeAbsoluteInstallPath(answer, question);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
 async function installPluginCommand(options) {
+  const shouldPromptForTarget = Boolean(
+    options.promptForTarget !== false && isInteractiveTerminal() && !options.targetDir
+  );
+  const recommendedTargetDir = await recommendPluginTargetDir("claude");
+  const targetDir = options.targetDir ? normalizeAbsoluteInstallPath(options.targetDir, "Claude plugin target") : shouldPromptForTarget ? await promptForInstallPath("Claude plugin directory", recommendedTargetDir) : recommendedTargetDir;
+  const previousTargetDir = await getConfiguredOrLegacyManagedPluginDir("claude");
+  const migrating = Boolean(previousTargetDir && previousTargetDir !== targetDir);
+  let previousInstall = previousTargetDir ? await inspectInstallPath("claude", previousTargetDir) : null;
+  const previousMarketplace = previousTargetDir ? await detectClaudeMarketplaceForTarget(previousTargetDir) : null;
+  const legacyTargetDir = getDefaultPluginTargetDir("claude");
+  const legacyInstall = targetDir !== legacyTargetDir ? await inspectInstallPath("claude", legacyTargetDir) : null;
+  if (migrating && previousInstall?.exists && !previousInstall.managed) {
+    throw new Error(
+      `${previousTargetDir} exists but is not a Syntaur-managed install. Remove it manually before changing the Claude plugin location.`
+    );
+  }
+  if (targetDir !== legacyTargetDir && legacyInstall?.exists && !legacyInstall.managed && (!previousTargetDir || previousTargetDir !== legacyTargetDir)) {
+    console.warn(
+      `Warning: ${legacyTargetDir} already exists and is not a Syntaur-managed install. Syntaur will use ${targetDir} instead.`
+    );
+  }
+  if (migrating && previousInstall?.exists && previousInstall.managed && isInteractiveTerminal()) {
+    const confirmed = await confirmPrompt(
+      `Move the Claude Code plugin from ${previousTargetDir} to ${targetDir} and remove the old install?`,
+      true
+    );
+    if (!confirmed) {
+      throw new Error("Install cancelled.");
+    }
+  }
   const result = await installManagedPlugin({
     pluginKind: "claude",
     force: options.force,
-    link: options.link
+    link: options.link,
+    targetDir
   });
-  console.log(`Installed Syntaur plugin:`);
+  const currentMarketplace = await detectClaudeMarketplaceForTarget(result.targetDir);
+  if (currentMarketplace) {
+    await ensureClaudeMarketplaceEntry({
+      marketplaceRootDir: currentMarketplace.rootDir,
+      manifestPath: currentMarketplace.manifestPath,
+      pluginTargetDir: result.targetDir,
+      expectedExistingPluginTargetDir: previousMarketplace && previousMarketplace.manifestPath === currentMarketplace.manifestPath ? previousTargetDir : null
+    });
+  }
+  await updateIntegrationConfig({ claudePluginDir: result.targetDir });
+  if (previousMarketplace && previousTargetDir && (!currentMarketplace || currentMarketplace.manifestPath !== previousMarketplace.manifestPath)) {
+    const removedMarketplaceEntry = await removeClaudeMarketplaceEntry({
+      manifestPath: previousMarketplace.manifestPath,
+      marketplaceRootDir: previousMarketplace.rootDir,
+      pluginTargetDir: previousTargetDir
+    });
+    if (removedMarketplaceEntry.removed) {
+      console.log(`Removed previous Claude marketplace entry from ${removedMarketplaceEntry.manifestPath}`);
+    }
+  }
+  if (migrating && previousInstall?.exists && previousInstall.managed && previousTargetDir) {
+    const removed = await uninstallManagedPlugin("claude", previousTargetDir);
+    if (removed.removed) {
+      console.log(`Removed previous Claude Code plugin from ${removed.targetDir}`);
+    }
+    previousInstall = null;
+  }
+  console.log("Installed Syntaur plugin:");
   console.log(`  target: ${result.targetDir}`);
   console.log(`  source: ${result.sourceDir}`);
   console.log(`  mode: ${result.mode}`);
-  console.log(`
-The plugin is now available in Claude Code.`);
-  console.log(`  Skills: /grab-assignment, /plan-assignment, /complete-assignment`);
-  console.log(`  Background: syntaur-protocol (auto-invoked)`);
-  console.log(`  Hook: write boundary enforcement (PreToolUse)`);
+  if (currentMarketplace) {
+    console.log(`  marketplace: ${currentMarketplace.manifestPath}`);
+  }
+  console.log("\nThe plugin is now available in Claude Code.");
+  console.log("  Skills: /grab-assignment, /plan-assignment, /complete-assignment");
+  console.log("  Background: syntaur-protocol (auto-invoked)");
+  console.log("  Hook: write boundary enforcement (PreToolUse)");
 }
 
 // src/commands/install-codex-plugin.ts
+init_config2();
+async function promptForInstallPath2(question, recommendedPath) {
+  while (true) {
+    const answer = await textPrompt(question, recommendedPath);
+    try {
+      return normalizeAbsoluteInstallPath(answer, question);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
 async function installCodexPluginCommand(options) {
+  const promptForTarget = Boolean(
+    options.promptForTarget !== false && isInteractiveTerminal() && (!options.targetDir || !options.marketplacePath)
+  );
+  const recommendedTargetDir = await recommendPluginTargetDir("codex");
+  const recommendedMarketplacePath = await recommendMarketplacePath();
+  const targetDir = options.targetDir ? normalizeAbsoluteInstallPath(options.targetDir, "Codex plugin target") : promptForTarget ? await promptForInstallPath2("Codex plugin directory", recommendedTargetDir) : recommendedTargetDir;
+  const marketplacePath = options.marketplacePath ? normalizeAbsoluteInstallPath(options.marketplacePath, "Codex marketplace path") : promptForTarget ? await promptForInstallPath2("Codex marketplace file path", recommendedMarketplacePath) : recommendedMarketplacePath;
+  const previousTargetDir = await getConfiguredOrLegacyManagedPluginDir("codex");
+  const previousMarketplacePath = await getConfiguredOrLegacyMarketplacePath();
+  const pluginPathChanged = Boolean(previousTargetDir && previousTargetDir !== targetDir);
+  const marketplacePathChanged = Boolean(
+    previousMarketplacePath && previousMarketplacePath !== marketplacePath
+  );
+  const previousInstall = previousTargetDir ? await inspectInstallPath("codex", previousTargetDir) : null;
+  const previousMarketplaceEntryExists = Boolean(
+    previousMarketplacePath && previousTargetDir && await hasSyntaurMarketplaceEntry(previousMarketplacePath, previousTargetDir)
+  );
+  if (pluginPathChanged && previousInstall?.exists && !previousInstall.managed) {
+    throw new Error(
+      `${previousTargetDir} exists but is not a Syntaur-managed install. Remove it manually before changing the Codex plugin location.`
+    );
+  }
+  if ((pluginPathChanged || marketplacePathChanged) && (previousInstall?.exists || previousMarketplaceEntryExists) && isInteractiveTerminal()) {
+    const confirmed = await confirmPrompt(
+      `Move the Codex integration to ${targetDir} and ${marketplacePath} and remove the previous Syntaur-managed integration?`,
+      true
+    );
+    if (!confirmed) {
+      throw new Error("Install cancelled.");
+    }
+  }
   const result = await installManagedPlugin({
     pluginKind: "codex",
     force: options.force,
-    link: options.link
+    link: options.link,
+    targetDir
+  });
+  const marketplace = await ensureMarketplaceEntry({
+    marketplacePath,
+    pluginTargetDir: result.targetDir,
+    expectedExistingPluginTargetDir: previousMarketplacePath === marketplacePath ? previousTargetDir : null
+  });
+  await updateIntegrationConfig({
+    codexPluginDir: result.targetDir,
+    codexMarketplacePath: marketplace.marketplacePath
   });
-  const marketplace = await ensureMarketplaceEntry();
+  if (pluginPathChanged && previousInstall?.exists && previousInstall.managed && previousTargetDir) {
+    const removed = await uninstallManagedPlugin("codex", previousTargetDir);
+    if (removed.removed) {
+      console.log(`Removed previous Codex plugin from ${removed.targetDir}`);
+    }
+  }
+  if (previousMarketplacePath && previousTargetDir && previousMarketplacePath !== marketplace.marketplacePath) {
+    const removedMarketplace = await removeMarketplaceEntry({
+      marketplacePath: previousMarketplacePath,
+      pluginTargetDir: previousTargetDir
+    });
+    if (removedMarketplace.removed) {
+      console.log(`Removed previous Codex marketplace entry from ${removedMarketplace.marketplacePath}`);
+    }
+  }
   console.log("Installed Syntaur Codex plugin:");
   console.log(`  target: ${result.targetDir}`);
   console.log(`  source: ${result.sourceDir}`);
   console.log(`  mode: ${result.mode}`);
-  console.log(`  marketplace: ${marketplace.changed ? marketplace.marketplacePath : getMarketplacePath()}`);
+  console.log(`  marketplace: ${marketplace.marketplacePath}`);
   console.log("\nThe plugin is now available to Codex.");
   console.log(
     "  Skills: syntaur-protocol, create-mission, create-assignment, grab-assignment, plan-assignment, complete-assignment, track-session"
@@ -7862,36 +8551,13 @@ async function installCodexPluginCommand(options) {
   console.log("  Hooks: write boundary enforcement, session cleanup");
 }
 
-// src/utils/prompt.ts
-import { stdin as input, stdout as output } from "process";
-import { createInterface } from "readline/promises";
-function isInteractiveTerminal() {
-  return Boolean(input.isTTY && output.isTTY);
-}
-async function confirmPrompt(question, defaultValue = false) {
-  if (!isInteractiveTerminal()) {
-    throw new Error("Interactive confirmation requires a TTY.");
-  }
-  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
-  const rl = createInterface({ input, output });
-  try {
-    const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase();
-    if (answer === "") {
-      return defaultValue;
-    }
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
-  }
-}
-
 // src/commands/setup.ts
 function printNonInteractiveSetupHelp() {
   console.error("Syntaur setup needs confirmation for optional steps when no TTY is available.");
   console.error("Run one of these commands instead:");
   console.error("  npx syntaur@latest setup --yes");
-  console.error(`  npx syntaur@latest setup --yes --claude`);
-  console.error(`  npx syntaur@latest setup --yes --codex`);
+  console.error("  npx syntaur@latest setup --yes --claude");
+  console.error("  npx syntaur@latest setup --yes --codex");
   console.error(`  npx syntaur@latest setup --yes --dashboard`);
 }
 async function setupCommand(options) {
@@ -7921,12 +8587,19 @@ async function setupCommand(options) {
     }
   }
   if (installClaude) {
-    await installPluginCommand({});
+    await installPluginCommand({
+      targetDir: options.claudeDir,
+      promptForTarget: !options.yes
+    });
   } else if (!interactive && !options.yes && !initialized) {
     console.log(`Skip Claude plugin for now. Install later with: ${getPluginInstallCommand("claude")}`);
   }
   if (installCodex) {
-    await installCodexPluginCommand({});
+    await installCodexPluginCommand({
+      targetDir: options.codexDir,
+      marketplacePath: options.codexMarketplacePath,
+      promptForTarget: !options.yes
+    });
   } else if (!interactive && !options.yes && !initialized) {
     console.log(`Skip Codex plugin for now. Install later with: ${getPluginInstallCommand("codex")}`);
   }
@@ -7984,19 +8657,44 @@ async function uninstallCommand(options) {
     }
   }
   if (targets.claude) {
-    const result = await uninstallManagedPlugin("claude");
+    const claudeTargetDir = await getConfiguredOrLegacyManagedPluginDir("claude");
+    const claudeMarketplace = claudeTargetDir ? await detectClaudeMarketplaceForTarget(claudeTargetDir) : null;
+    const result = await uninstallManagedPlugin(
+      "claude",
+      claudeTargetDir ?? void 0
+    );
     console.log(
       result.removed ? `Removed Claude Code plugin from ${result.targetDir}` : `Claude Code plugin not installed at ${result.targetDir}`
     );
+    if (claudeMarketplace) {
+      const removedMarketplaceEntry = await removeClaudeMarketplaceEntry({
+        manifestPath: claudeMarketplace.manifestPath,
+        marketplaceRootDir: claudeMarketplace.rootDir,
+        pluginTargetDir: claudeTargetDir ?? void 0
+      });
+      if (removedMarketplaceEntry.removed) {
+        console.log(`Removed Claude marketplace entry from ${removedMarketplaceEntry.manifestPath}`);
+      }
+    }
   }
   if (targets.codex) {
-    const result = await uninstallManagedPlugin("codex");
+    const codexTargetDir = await getConfiguredOrLegacyManagedPluginDir("codex");
+    const marketplacePath = await getConfiguredOrLegacyMarketplacePath();
+    const result = await uninstallManagedPlugin(
+      "codex",
+      codexTargetDir ?? void 0
+    );
     console.log(
       result.removed ? `Removed Codex plugin from ${result.targetDir}` : `Codex plugin not installed at ${result.targetDir}`
     );
-    const marketplace = await removeMarketplaceEntry();
-    if (marketplace.removed) {
-      console.log(`Removed Codex marketplace entry from ${marketplace.marketplacePath}`);
+    if (marketplacePath) {
+      const marketplace = await removeMarketplaceEntry({
+        marketplacePath,
+        pluginTargetDir: codexTargetDir ?? void 0
+      });
+      if (marketplace.removed) {
+        console.log(`Removed Codex marketplace entry from ${marketplace.marketplacePath}`);
+      }
     }
   }
   if (targets.data) {
@@ -8017,7 +8715,7 @@ async function uninstallCommand(options) {
 // src/commands/setup-adapter.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve30 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
@@ -8116,7 +8814,7 @@ async function setupAdapterCommand(framework, options) {
 // src/commands/track-session.ts
 init_paths();
 init_fs();
-init_config();
+init_config2();
 import { resolve as resolve31 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function trackSessionCommand(options) {
@@ -8153,7 +8851,7 @@ async function trackSessionCommand(options) {
 }
 
 // src/commands/browse.ts
-init_config();
+init_config2();
 async function browseCommand(options) {
   const config = await readConfig();
   const missionsDir = config.defaultMissionDir;
@@ -8215,7 +8913,7 @@ Use --slug to specify a different slug.`
 init_paths();
 init_fs();
 init_parser();
-import { readdir as readdir8, readFile as readFile13 } from "fs/promises";
+import { readdir as readdir9, readFile as readFile13 } from "fs/promises";
 import { resolve as resolve34 } from "path";
 async function listPlaybooksCommand() {
   const dir = playbooksDir();
@@ -8223,7 +8921,7 @@ async function listPlaybooksCommand() {
     console.log('No playbooks directory found. Run "syntaur init" first.');
     return;
   }
-  const entries = await readdir8(dir, { withFileTypes: true });
+  const entries = await readdir9(dir, { withFileTypes: true });
   const mdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md");
   if (mdFiles.length === 0) {
     console.log('No playbooks found. Create one with "syntaur create-playbook <name>".');
@@ -8785,7 +9483,7 @@ program.command("reopen").description("Reopen a completed or failed assignment")
     process.exit(1);
   }
 });
-program.command("setup").description("Initialize Syntaur and optionally install plugins or launch the dashboard").option("--yes", "Skip interactive prompts and perform only the requested flags").option("--claude", "Install the Claude Code plugin").option("--codex", "Install the Codex plugin").option("--dashboard", "Launch the dashboard after setup").action(async (options) => {
+program.command("setup").description("Initialize Syntaur and optionally install plugins or launch the dashboard").option("--yes", "Skip interactive prompts and perform only the requested flags").option("--claude", "Install the Claude Code plugin").option("--codex", "Install the Codex plugin").option("--claude-dir <path>", "Install the Claude Code plugin at a specific path").option("--codex-dir <path>", "Install the Codex plugin at a specific path").option("--codex-marketplace-path <path>", "Write the Codex marketplace entry to a specific file").option("--dashboard", "Launch the dashboard after setup").action(async (options) => {
   try {
     await setupCommand(options);
   } catch (error) {
@@ -8796,9 +9494,9 @@ program.command("setup").description("Initialize Syntaur and optionally install
     process.exit(1);
   }
 });
-program.command("install-plugin").description("Install the Syntaur Claude Code plugin").option("--force", "Overwrite an existing Syntaur-managed install").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
+program.command("install-plugin").description("Install the Syntaur Claude Code plugin").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
   try {
-    await installPluginCommand(options);
+    await installPluginCommand({ ...options, promptForTarget: true });
   } catch (error) {
     console.error(
       "Error:",
@@ -8807,9 +9505,9 @@ program.command("install-plugin").description("Install the Syntaur Claude Code p
     process.exit(1);
   }
 });
-program.command("install-codex-plugin").description("Install the Syntaur Codex plugin and home marketplace entry").option("--force", "Overwrite an existing Syntaur-managed install").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
+program.command("install-codex-plugin").description("Install the Syntaur Codex plugin and marketplace entry").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--marketplace-path <path>", "Write the marketplace entry to a specific file").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
   try {
-    await installCodexPluginCommand(options);
+    await installCodexPluginCommand({ ...options, promptForTarget: true });
   } catch (error) {
     console.error(
       "Error:",