@launchchair/agent 0.4.11 → 0.5.0

package/launchchair-cli.mjs

@@ -14,8 +14,13 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
+import {
+  bindProjectWorkspace,
+  listProjectWorkspaceBindings,
+  unbindProjectWorkspace,
+} from "./project-workspace.mjs";
 
-const VERSION = "0.4.11";
+const VERSION = "0.5.0";
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const DEFAULT_BASE_URL = "https://www.launchchair.io";
 const CONFIG_DIR = process.env.LAUNCHCHAIR_CONFIG_DIR?.trim()
@@ -104,10 +109,16 @@ function configValue(key, envNames = [], fallback = "") {
 }
 
 function token() {
+  const config = loadConfig();
+  if (config.mcpLoggedOut === true) return "";
+  if (config.mcpPreferSavedToken === true && config.agentToken) return config.agentToken;
   return configValue("agentToken", ["LAUNCHCHAIR_AGENT_TOKEN", "LAUNCHCHAIR_API_KEY"]);
 }
 
 function tokenSource() {
+  const config = loadConfig();
+  if (config.mcpLoggedOut === true) return "logged out";
+  if (config.mcpPreferSavedToken === true && config.agentToken) return CONFIG_PATH;
   if (env("LAUNCHCHAIR_AGENT_TOKEN")) return "LAUNCHCHAIR_AGENT_TOKEN";
   if (env("LAUNCHCHAIR_API_KEY")) return "LAUNCHCHAIR_API_KEY";
   if (loadConfig().agentToken) return CONFIG_PATH;
@@ -166,6 +177,7 @@ Use MCP-only when you want agent tools inside Codex/Claude/Hermes.
 Use CLI + MCP when you also want quick terminal commands, diagnostics, and bridge control.
 
 Commands:
+  --version                      Show the installed package version
   doctor                         Check token, docs, API reachability, and local bridge files
   login [--token TOKEN]           Open browser login and save a LaunchChair Agent API token locally
   logout                          Remove the saved local token
@@ -178,10 +190,15 @@ Commands:
   run-once                        Claim and run one queued LaunchChair job through the local bridge
   bridge                          Start the long-running local bridge for Run with Agent
   mcp-server                      Run the stdio MCP server using saved CLI config
+  tools [--json]                 List the available MCP tools and their input schemas
+  call TOOL [--json JSON|--input FILE]
+                                  Call any MCP tool; JSON output, nonzero exit on tool errors
   setup codex|claude|claude-desktop|claude-code|terminal [options]
-                                  Guided setup for CLI, CWD, AGENTS.md, MCP config, and bridge
+                                  Guided global CLI/MCP setup with isolated project workspaces
+  bind --project-id ID --cwd PATH Bind one LaunchChair project to a verified local Git clone
+  unbind --project-id ID           Remove one project's saved local repository binding
   config                          Show local CLI config without printing the token
-  config set KEY VALUE             Save base-url, project-id, codex-cwd, or claude-code-cwd
+  config set KEY VALUE             Save base-url or project-id
   mcp-config codex|claude [options]
                                   Print MCP config or Codex custom MCP form fields
   install-agent-md [--cwd PATH]   Create a small AGENTS.md pointer in a fresh repo
@@ -195,6 +212,8 @@ Create options:
   --start-loop
   --save-project                  Save the created project id as the CLI default
   --idempotency-key KEY
+  --idea-intent preserve|explore   Default: preserve the supplied idea, even with low scores
+  --validation-gate very_high     Require pain >=85, opportunity >=85, saturation <=30 before build
 
 Feature create options:
   --project-kind feature
@@ -215,7 +234,7 @@ Continue options:
   --completion-target TEXT        Natural-language target for the loop run
 
 Setup options:
-  --cwd PATH                      Repo folder or empty folder the agent should build into
+  --cwd PATH                      Bind this repo only when --project-id is also supplied
   --token TOKEN                   Optional manual lc_at token fallback to save during setup
   --project-id ID                 Optional default LaunchChair project id
   --base-url URL                  Optional LaunchChair base URL
@@ -238,16 +257,21 @@ Login options:
   --timeout SECONDS               Default: 600
 
 Env:
-  LAUNCHCHAIR_AGENT_TOKEN         Optional full lc_at token override
+  LAUNCHCHAIR_AGENT_TOKEN         Optional token fallback when no saved login takes precedence
   LAUNCHCHAIR_BASE_URL            Default: https://www.launchchair.io
   LAUNCHCHAIR_PROJECT_ID          Optional default project id
-  LC_AGENT_CODEX_CWD              Folder Codex should build into
-  LC_AGENT_CLAUDE_CODE_CWD        Folder Claude Code should build into
+  LC_AGENT_CODEX_CWD              Legacy candidate only; verified per project before use
+  LC_AGENT_CLAUDE_CODE_CWD        Legacy candidate only; verified per project before use
 
 MCP config options:
   --ui-fields                     Print fields for Codex Desktop's custom MCP form
   --copy-config                   Copy generated output to clipboard on macOS
 
+Tool call options:
+  --json JSON                     Tool arguments as a JSON object; defaults to {}
+  --input FILE                    Read tool arguments from a JSON file; use - for stdin
+  --timeout SECONDS               Request timeout. Default: 60, max: 3600
+
 Config:
   ${CONFIG_PATH}
 `);
@@ -301,7 +325,13 @@ async function api(pathname, options = {}) {
   if (!response.ok) {
     const retryAfter = response.headers.get("retry-after");
     const suffix = retryAfter ? ` Retry after ${retryAfter}s.` : "";
-    throw new Error(`${body?.error ?? response.statusText}${suffix}`);
+    const next = body?.upgradeUrl
+      ? ` Upgrade: ${body.upgradeUrl}`
+      : response.status === 401 ? " Run launchchair login to reconnect." : "";
+    const error = new Error(`${body?.error ?? response.statusText}${suffix}${next}`);
+    error.status = response.status;
+    error.retryAfterSeconds = Number(retryAfter) || 10;
+    throw error;
   }
   return body;
 }
@@ -324,7 +354,10 @@ async function publicApi(pathname, options = {}) {
   if (!response.ok) {
     const retryAfter = response.headers.get("retry-after");
     const suffix = retryAfter ? ` Retry after ${retryAfter}s.` : "";
-    throw new Error(`${body?.error ?? response.statusText}${suffix}`);
+    const error = new Error(`${body?.error ?? response.statusText}${suffix}`);
+    error.status = response.status;
+    error.retryAfterSeconds = Number(retryAfter) || 10;
+    throw error;
   }
   return body;
 }
@@ -384,6 +417,8 @@ async function login(args) {
     }
     saveConfig({
       agentToken: incomingToken,
+      mcpLoggedOut: false,
+      mcpPreferSavedToken: true,
       baseUrl: incomingBaseUrl ?? baseUrl(),
       projectId: incomingProjectId || defaultProjectId() || undefined,
     });
@@ -427,7 +462,7 @@ async function login(args) {
 
   const timeoutSeconds =
     typeof args.timeout === "string" && Number.isFinite(Number(args.timeout)) ? Math.max(10, Number(args.timeout)) : Number(start.expiresIn ?? 600);
-  const intervalSeconds = Math.max(2, Number(start.interval ?? 2));
+  let intervalSeconds = Math.max(5, Number(start.interval ?? 5));
   const startedAt = Date.now();
   print("");
   print("Waiting for approval. Leave this terminal open.");
@@ -442,10 +477,12 @@ async function login(args) {
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      if (error.status === 429) { intervalSeconds = Math.max(5, error.retryAfterSeconds); continue; }
       if (/pending/i.test(message)) continue;
       throw error;
     }
     if (poll?.status === "pending") {
+      intervalSeconds = Math.max(5, Number(poll.interval) || intervalSeconds);
       write(paint(".", "dim"));
       continue;
     }
@@ -453,6 +490,8 @@ async function login(args) {
       print("");
       saveConfig({
         agentToken: poll.token,
+        mcpLoggedOut: false,
+        mcpPreferSavedToken: true,
         baseUrl: baseUrl(),
         projectId: incomingProjectId || defaultProjectId() || undefined,
       });
@@ -471,11 +510,12 @@ async function login(args) {
 }
 
 function logout() {
-  deleteConfigKeys(["agentToken"]);
+  deleteConfigKeys(["agentToken", "pendingMcpLogin"]);
+  saveConfig({ mcpLoggedOut: true });
   title("CLI logout");
   ok(`Removed saved token from ${CONFIG_PATH}`);
   if (env("LAUNCHCHAIR_AGENT_TOKEN") || env("LAUNCHCHAIR_API_KEY")) {
-    warn("An environment token is still set, so CLI commands may remain authenticated in this shell.");
+    warn("An environment token is still set; it remains ignored until you log in again.");
   }
 }
 
@@ -599,6 +639,14 @@ async function createProject(args) {
     throw new Error("--project-kind must be product or feature.");
   }
   const featureProject = projectKind === "feature";
+  const ideaIntent = args["idea-intent"] ?? "preserve";
+  if (!["preserve", "explore"].includes(ideaIntent)) {
+    throw new Error("--idea-intent must be preserve or explore.");
+  }
+  const validationGate = args["validation-gate"];
+  if (validationGate !== undefined && validationGate !== "very_high") {
+    throw new Error("--validation-gate must be very_high. For custom thresholds, use launchchair call create_project --input FILE.");
+  }
   const featureDescription = String(args["feature-description"] ?? args["one-liner"] ?? "").trim();
   const featureProblem = String(args.problem ?? "").trim();
   if (featureProject && (!featureDescription || !featureProblem)) {
@@ -657,7 +705,7 @@ async function createProject(args) {
   const body = await api("/api/agent/v1/projects", {
     method: "POST",
     headers,
-    body: JSON.stringify(requestBody),
+    body: JSON.stringify({ ...requestBody, ideaIntent, validationGate }),
   });
   const projectId = body?.project?.id ?? body?.projectId ?? "";
   title("Project created");
@@ -767,9 +815,9 @@ function buildBridgeEnv(projectId = defaultProjectId()) {
     LAUNCHCHAIR_CONFIG_DIR: CONFIG_DIR,
     LAUNCHCHAIR_AGENT_TOKEN: token(),
     LAUNCHCHAIR_PROJECT_ID: projectId,
-    LC_AGENT_CODEX_CWD: configValue("codexCwd", ["LC_AGENT_CODEX_CWD"], ""),
-    LC_AGENT_CLAUDE_CODE_CWD: configValue("claudeCodeCwd", ["LC_AGENT_CLAUDE_CODE_CWD"], ""),
   };
+  delete childEnv.LC_AGENT_CODEX_CWD;
+  delete childEnv.LC_AGENT_CLAUDE_CODE_CWD;
   Object.keys(childEnv).forEach((key) => {
     if (childEnv[key] === undefined || childEnv[key] === null || childEnv[key] === "") {
       delete childEnv[key];
@@ -869,6 +917,100 @@ function spawnMcpServer(extraArgs = []) {
   });
 }
 
+// Use the bundled MCP so terminal calls share its login, scope checks, and host workflow.
+async function requestMcp(method, params, timeoutMs = 60_000) {
+  const child = spawn(process.execPath, [path.join(SCRIPT_DIR, "mcp-bridge-server.mjs")], {
+    env: buildBridgeEnv(),
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  let buffer = "";
+  let serial = 0;
+  const pending = new Map();
+  const failPending = (error) => {
+    for (const entry of pending.values()) { clearTimeout(entry.timer); entry.reject(error); }
+    pending.clear();
+  };
+  child.on("error", failPending);
+  child.on("exit", (code) => failPending(new Error(`MCP server exited before replying (code ${code ?? "unknown"}).`)));
+  child.stdin.on("error", failPending);
+  child.stderr.on("data", (chunk) => process.stderr.write(chunk));
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    let newline;
+    while ((newline = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try { message = JSON.parse(line); }
+      catch { failPending(new Error("MCP server returned invalid JSON.")); return; }
+      const entry = pending.get(message.id);
+      if (!entry) continue;
+      pending.delete(message.id);
+      clearTimeout(entry.timer);
+      if (message.error) entry.reject(new Error(message.error.message || "MCP request failed."));
+      else entry.resolve(message.result);
+    }
+  });
+  const rpc = (rpcMethod, rpcParams) => new Promise((resolve, reject) => {
+    const id = ++serial;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error("MCP request timed out. Check the project's run status before retrying a write."));
+    }, timeoutMs);
+    pending.set(id, { resolve, reject, timer });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method: rpcMethod, params: rpcParams })}\n`);
+  });
+  try {
+    await rpc("initialize", { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "launchchair-cli", version: VERSION } });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}\n`);
+    return await rpc(method, params);
+  } finally {
+    child.stdin.end();
+    child.kill();
+    failPending(new Error("MCP client closed."));
+  }
+}
+
+async function listTools(args) {
+  const result = await requestMcp("tools/list", {});
+  if (args.json === true) return print(JSON.stringify(result, null, 2));
+  title("MCP tools");
+  for (const tool of result.tools ?? []) print(`${tool.name}\n  ${tool.description}`);
+  print("\nUse launchchair tools --json for input schemas, then launchchair call TOOL --json '{...}'.");
+}
+
+async function callTool(args) {
+  const requestedName = args._[0];
+  if (!requestedName) throw new Error("call requires a tool name. Run launchchair tools to list them.");
+  if (args.json !== undefined && args.input !== undefined) throw new Error("Use either --json or --input, not both.");
+  let input = "{}";
+  if (args.json !== undefined) {
+    if (typeof args.json !== "string") throw new Error("--json requires a JSON object.");
+    input = args.json;
+  } else if (args.input !== undefined) {
+    if (typeof args.input !== "string") throw new Error("--input requires a file path or - for stdin.");
+    input = readFileSync(args.input === "-" ? 0 : path.resolve(args.input), "utf8");
+  }
+  let toolArgs;
+  try { toolArgs = JSON.parse(input); }
+  catch { throw new Error("Tool arguments must be valid JSON."); }
+  if (!toolArgs || typeof toolArgs !== "object" || Array.isArray(toolArgs)) throw new Error("Tool arguments must be a JSON object.");
+  const timeoutSeconds = args.timeout === undefined ? 60 : Number(args.timeout);
+  if (typeof args.timeout === "boolean" || !Number.isFinite(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > 3600) {
+    throw new Error("--timeout must be between 1 and 3600 seconds.");
+  }
+  const result = await requestMcp("tools/call", {
+    name: requestedName.startsWith("launchchair_") ? requestedName : `launchchair_${requestedName}`,
+    arguments: toolArgs,
+  }, timeoutSeconds * 1000);
+  // LaunchChair tools return one JSON text block. Keep other MCP content intact.
+  print(result.content?.length === 1 && result.content[0].type === "text"
+    ? result.content[0].text : JSON.stringify(result, null, 2));
+  if (result.isError) process.exitCode = 1;
+}
+
 function normalizedMcpTarget(target) {
   return targetDetails(target || "codex").mcpTarget || "codex";
 }
@@ -878,18 +1020,14 @@ function tomlString(value) {
 }
 
 function mcpEnvForTarget(target, options = {}) {
-  const includeTokenPlaceholder = options.includeTokenPlaceholder !== false;
   const details = targetDetails(target || "codex");
   const projectId = defaultProjectId();
-  const cwd = configValue(details.cwdConfigKey, [details.cwdEnvName], "/absolute/path/to/repo-or-empty-folder");
   const envBlock = {
     LAUNCHCHAIR_BASE_URL: baseUrl(),
     LAUNCHCHAIR_CONFIG_DIR: CONFIG_DIR,
-    ...(token() || !includeTokenPlaceholder ? {} : { LAUNCHCHAIR_AGENT_TOKEN: "<optional full lc_at token when launchchair login was not used>" }),
     ...(projectId ? { LAUNCHCHAIR_PROJECT_ID: projectId } : {}),
     LC_AGENT_ROUTER_GPT_TARGET: details.routerTarget,
     LC_AGENT_ROUTER_CODEX_TARGET: details.routerTarget,
-    [details.cwdEnvName]: cwd,
   };
   return Object.fromEntries(Object.entries(envBlock).filter(([, value]) => String(value ?? "").trim()));
 }
@@ -911,6 +1049,7 @@ function verifyMcpServer(target, timeoutMs = 20_000) {
       stdio: ["pipe", "pipe", "pipe"],
     });
     let settled = false;
+    let discoveredTools = [];
     let stdout = "";
     let stderr = "";
 
@@ -961,13 +1100,29 @@ function verifyMcpServer(target, timeoutMs = 20_000) {
           const toolNames = Array.isArray(response?.result?.tools)
             ? response.result.tools.map((tool) => String(tool?.name || "")).filter(Boolean)
             : [];
-          const requiredTools = ["launchchair_status", "launchchair_create_project", "launchchair_list_projects"];
+          const requiredTools = [
+            "launchchair_status", "launchchair_create_project", "launchchair_list_projects",
+            "launchchair_login", "launchchair_login_status", "launchchair_create_token",
+            "launchchair_next_step", "launchchair_complete_run", "launchchair_get_validation_gate",
+            "launchchair_update_bucket", "launchchair_get_starter", "launchchair_export_mvp_spec",
+          ];
           const missingTools = requiredTools.filter((name) => !toolNames.includes(name));
           if (missingTools.length) {
             finish(new Error(`MCP verification did not discover required tools: ${missingTools.join(", ")}`));
             return;
           }
-          finish(null, toolNames);
+          discoveredTools = toolNames;
+          if (!token()) { finish(null, toolNames); continue; }
+          send({ jsonrpc: "2.0", id: 3, method: "tools/call", params: { name: "launchchair_status", arguments: {} } });
+        }
+        if (response?.id === 3) {
+          let status = {};
+          try { status = JSON.parse(response.result?.content?.[0]?.text || "{}"); } catch {}
+          if (response.error || response.result?.isError || status.authenticated !== true) {
+            finish(new Error(`MCP authentication verification failed: ${status.error || response.error?.message || "not authenticated"}`));
+            return;
+          }
+          finish(null, discoveredTools);
         }
       }
     });
@@ -1025,13 +1180,12 @@ ${envLines}`;
 
 function renderMcpUiFields(target) {
   const normalized = normalizedMcpTarget(target);
-  const details = targetDetails(normalized);
   const server = mcpServerConfig(normalized);
   const envLines =
     Object.entries(server.env)
       .map(([key, value]) => `  ${key} = ${value}`)
       .join("\n") || "  (none)";
-  const workingDir = server.env[details.cwdEnvName] || process.cwd();
+  const workingDir = path.join(CONFIG_DIR, "projects");
   return `Name
   launchchair
 
@@ -1173,14 +1327,20 @@ function printMcpConfig(target, args = {}) {
 
 function showConfig() {
   const config = loadConfig();
+  const bindings = listProjectWorkspaceBindings(CONFIG_PATH);
   title("CLI config");
   row("Path", CONFIG_PATH, existsSync(CONFIG_PATH) ? "dim" : "yellow");
   row("Base URL", baseUrl(), "cyan");
   row("Token", maskToken(token()), token() ? "green" : "yellow");
   row("Token source", tokenSource(), token() ? "green" : "yellow");
   row("Project ID", defaultProjectId() || "not set", defaultProjectId() ? "cyan" : "dim");
-  row("Codex CWD", configValue("codexCwd", ["LC_AGENT_CODEX_CWD"], "not set"), config.codexCwd || env("LC_AGENT_CODEX_CWD") ? "cyan" : "dim");
-  row("Claude Code CWD", configValue("claudeCodeCwd", ["LC_AGENT_CLAUDE_CODE_CWD"], "not set"), config.claudeCodeCwd || env("LC_AGENT_CLAUDE_CODE_CWD") ? "cyan" : "dim");
+  row("Project bindings", Object.keys(bindings).length, Object.keys(bindings).length > 0 ? "cyan" : "dim");
+  for (const [projectId, binding] of Object.entries(bindings)) {
+    row(`  ${projectId.slice(0, 12)}`, typeof binding === "string" ? binding : binding?.path ?? "invalid", "cyan");
+  }
+  if (config.codexCwd || config.claudeCodeCwd || env("LC_AGENT_CODEX_CWD") || env("LC_AGENT_CLAUDE_CODE_CWD")) {
+    row("Legacy CWD", "ignored unless its Git origin matches the current project", "yellow");
+  }
 }
 
 function setConfig(args) {
@@ -1189,16 +1349,50 @@ function setConfig(args) {
   const allowed = {
     "base-url": "baseUrl",
     "project-id": "projectId",
-    "codex-cwd": "codexCwd",
-    "claude-code-cwd": "claudeCodeCwd",
   };
   if (!key || !value || !allowed[key]) {
-    throw new Error("Usage: launchchair config set base-url|project-id|codex-cwd|claude-code-cwd VALUE");
+    throw new Error("Usage: launchchair config set base-url|project-id VALUE. Use launchchair bind for local repositories.");
   }
   saveConfig({ [allowed[key]]: key === "base-url" ? value.replace(/\/+$/, "") : value });
   ok(`Saved ${key} to ${CONFIG_PATH}`);
 }
 
+async function getRunnerWorkspaceContext(projectId) {
+  const payload = await api(`/api/agent/v1/projects/${encodeURIComponent(projectId)}/runner-workspace`);
+  return payload?.workspace && typeof payload.workspace === "object" ? payload.workspace : { projectId };
+}
+
+async function bindProject(args) {
+  const projectId = String(args["project-id"] || defaultProjectId() || "").trim();
+  const cwd = String(args.cwd || "").trim();
+  if (!projectId || !cwd) {
+    throw new Error("Usage: launchchair bind --project-id ID --cwd /absolute/path/to/repo");
+  }
+  const context = await getRunnerWorkspaceContext(projectId);
+  const repository = context?.repository && typeof context.repository === "object" ? context.repository : {};
+  const binding = bindProjectWorkspace({
+    configPath: CONFIG_PATH,
+    projectId,
+    cwd,
+    repositoryUrl: String(repository.repoUrl || repository.cloneUrl || "").trim(),
+  });
+  installAgentMd({ cwd: binding.path });
+  title("project repository bound");
+  row("Project ID", projectId, "cyan");
+  row("Local repository", binding.path, "cyan");
+  if (binding.repositoryUrl) row("Verified origin", binding.repositoryUrl, "green");
+  ok("Future runs for this LaunchChair project will use this repository.");
+  ok("Already-running bridges will pick up this binding on the next run.");
+}
+
+function unbindProject(args) {
+  const projectId = String(args["project-id"] || defaultProjectId() || "").trim();
+  if (!projectId) throw new Error("Usage: launchchair unbind --project-id ID");
+  const existed = unbindProjectWorkspace({ configPath: CONFIG_PATH, projectId });
+  if (existed) ok(`Removed local repository binding for ${projectId}.`);
+  else warn(`No local repository binding existed for ${projectId}.`);
+}
+
 function installAgentMd(args) {
   const cwd = path.resolve(String(args.cwd || process.cwd()));
   const target = path.join(cwd, "AGENTS.md");
@@ -1242,7 +1436,10 @@ function installLaunchChairSkill(args) {
       "# LaunchChair workflow",
       "",
       "Use the installed LaunchChair MCP tools before web search or local repo discovery for LaunchChair project work.",
-      "Call launchchair_status if capability context is unclear.",
+      "Call launchchair_status if capability context is unclear. If login is required, use launchchair_login and launchchair_login_status; never print token secrets.",
+      "Prefer launchchair_next_step and execute its claimed prompt in this host agent using existing plugins, then complete_run. Use local runners only when explicitly requested.",
+      "Preserve supplied ideas and requirements even when validation is low. ideaIntent=preserve is the default; exploration and pivots require an explicit user request.",
+      "Only impose a validation gate when requested. VERY high means validationGate=very_high (pain>=85, opportunity>=85, saturation<=30). Never fabricate evidence or weaken the gate.",
       "For a new product, use launchchair_create_project.",
       "For a feature in an existing product, use launchchair_create_feature_project. Never substitute a Product project if that tool is unavailable; report the setup or authentication issue instead.",
       "Use planToBuildBoard=true for planning through the Feature build board.",
@@ -1258,17 +1455,23 @@ function installLaunchChairSkill(args) {
 
 async function setup(args) {
   const details = targetDetails(args._[0] || "codex");
-  const cwd = path.resolve(String(args.cwd || process.cwd()));
+  const requestedCwd = typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd.trim()) : "";
   const writeConfig =
     args["write-config"] === true ||
     (args["copy-config"] !== true && args["ui-fields"] !== true && args["print-config"] !== true);
   const incomingToken = typeof args.token === "string" ? args.token.trim() : "";
   const incomingBaseUrl = typeof args["base-url"] === "string" ? args["base-url"].trim().replace(/\/+$/, "") : undefined;
   const incomingProjectId = typeof args["project-id"] === "string" ? args["project-id"].trim() : "";
+  const bindingProjectId = incomingProjectId || defaultProjectId();
+
+  if (requestedCwd && !bindingProjectId) {
+    throw new Error("--cwd must be paired with --project-id. Global runner directories are no longer supported.");
+  }
 
   title(`guided setup for ${details.label}`);
-  mkdirSync(cwd, { recursive: true });
-  ok(`Build folder ready: ${cwd}`);
+  const projectWorkspaceRoot = path.join(CONFIG_DIR, "projects");
+  mkdirSync(projectWorkspaceRoot, { recursive: true, mode: 0o700 });
+  ok(`Isolated project workspace root ready: ${projectWorkspaceRoot}`);
 
   if (incomingToken) {
     if (!incomingToken.startsWith("lc_at_")) {
@@ -1276,6 +1479,8 @@ async function setup(args) {
     }
     saveConfig({
       agentToken: incomingToken,
+      mcpLoggedOut: false,
+      mcpPreferSavedToken: true,
       baseUrl: incomingBaseUrl ?? baseUrl(),
       projectId: incomingProjectId || defaultProjectId() || undefined,
     });
@@ -1287,10 +1492,6 @@ async function setup(args) {
     });
   }
 
-  saveConfig({ [details.cwdConfigKey]: cwd });
-  ok(`Saved ${details.cwdEnvName}: ${cwd}`);
-  installAgentMd({ cwd });
-
   if (!token() && args["skip-login"] !== true) {
     print("");
     warn("No saved LaunchChair token found. Starting browser approval now.");
@@ -1306,8 +1507,12 @@ async function setup(args) {
     });
   }
 
+  if (requestedCwd) {
+    await bindProject({ "project-id": bindingProjectId, cwd: requestedCwd });
+  }
+
   if (details.mcpTarget === "codex") {
-    installLaunchChairSkill({ cwd });
+    installLaunchChairSkill({ cwd: path.dirname(CONFIG_DIR) });
   }
 
   print("");
@@ -1362,11 +1567,11 @@ async function setup(args) {
     }
   }
 
-  if (!details.terminalOnly && token() && args["skip-mcp-check"] !== true) {
+  if (!details.terminalOnly && args["skip-mcp-check"] !== true) {
     const toolNames = await verifyMcpServer(details.mcpTarget);
     print("");
-    title("MCP verification passed");
-    ok(`Initialize and tools/list succeeded; discovered ${toolNames.length} LaunchChair tools.`);
+    title(token() ? "MCP verification passed" : "MCP discovery verified — login required");
+    ok(`Discovered ${toolNames.length} LaunchChair tools.${token() ? " Authenticated status verified." : " Call launchchair_login in your agent."}`);
   } else if (!details.terminalOnly && !token()) {
     warn("MCP verification was skipped because no LaunchChair token is configured.");
   } else if (!details.terminalOnly && args["skip-mcp-check"] === true) {
@@ -1405,12 +1610,13 @@ async function setup(args) {
       print(`2. Restart or reload ${details.label} so the MCP server is exposed to fresh chats.`);
     }
     print("Use the generated command and argument fields exactly as printed; setup resolves the local Node and CLI paths for this machine.");
-    print("Keep this bridge running when you want LaunchChair's Run with agent button to work:");
+    print("Your agent can use launchchair_next_step and launchchair_complete_run with its connected plugins.");
+    print("For unattended local-runner jobs queued from LaunchChair's Run with agent button, optionally run:");
     print(`   ${paint("launchchair bridge", "cyan")}`);
     print("Start a fresh agent chat. The agent should discover the LaunchChair MCP tools automatically.");
   }
   print("");
-  row("Build folder", cwd, "cyan");
+  row("Workspace mode", requestedCwd ? `project-bound: ${requestedCwd}` : "isolated per LaunchChair project", "cyan");
   row("Runner target", details.routerTarget, "cyan");
   row("Config file", CONFIG_PATH, "dim");
 
@@ -1429,6 +1635,7 @@ async function main() {
   const [command = "help", ...rest] = process.argv.slice(2);
   const args = parseArgs(rest);
   if (command === "help" || command === "--help" || command === "-h") return help();
+  if (command === "--version" || command === "-v" || command === "version") return print(VERSION);
   if (command === "doctor") return doctor();
   if (command === "login") return login(args);
   if (command === "logout") return logout();
@@ -1440,7 +1647,11 @@ async function main() {
   if (command === "run-once") return spawnBridge(["--once", "--verbose"]);
   if (command === "bridge") return spawnBridge(["--verbose"]);
   if (command === "mcp-server") return spawnMcpServer();
+  if (command === "tools") return listTools(args);
+  if (command === "call") return callTool(args);
   if (command === "setup") return setup(args);
+  if (command === "bind") return bindProject(args);
+  if (command === "unbind") return unbindProject(args);
   if (command === "config" && args._[0] === "set") return setConfig({ ...args, _: args._.slice(1) });
   if (command === "config") return showConfig();
   if (command === "mcp-config") return printMcpConfig(args._[0] || "codex", args);