@launchchair/agent 0.4.12 → 0.5.0

package/AGENTS.md

@@ -35,6 +35,7 @@ mkdir -p "$HOME/launchchair-agent"
 curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/local-bridge.mjs" -o "$HOME/launchchair-agent/local-bridge.mjs"
 curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/launchchair-cli.mjs" -o "$HOME/launchchair-agent/launchchair-cli.mjs"
 curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/mcp-bridge-server.mjs" -o "$HOME/launchchair-agent/mcp-bridge-server.mjs"
+curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/mcp-capabilities.mjs" -o "$HOME/launchchair-agent/mcp-capabilities.mjs"
 curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/project-workspace.mjs" -o "$HOME/launchchair-agent/project-workspace.mjs"
 curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/runner-command.mjs" -o "$HOME/launchchair-agent/runner-command.mjs"
 curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/codex-runner.mjs" -o "$HOME/launchchair-agent/codex-runner.mjs"
@@ -75,7 +76,7 @@ LAUNCHCHAIR_BASE_URL="https://www.launchchair.io"
 LAUNCHCHAIR_PROJECT_ID="optional project UUID; omit or leave blank if creating or discovering a project"
 ```
 
-`launchchair login` is the recommended token path. It saves the token to `~/.launchchair/config.json`, and `launchchair mcp-server` reads that saved token. Use `LAUNCHCHAIR_AGENT_TOKEN` only as a manual fallback when browser login is skipped or a per-client token override is needed.
+`launchchair login` saves the token to `~/.launchchair/config.json`, shared by the CLI and MCP. Use `LAUNCHCHAIR_AGENT_TOKEN` as a manual fallback when browser login is skipped. A fresh saved login takes precedence over stale environment credentials; logout disables authentication until login. Use a separate `LAUNCHCHAIR_CONFIG_DIR` for a separate per-client account.
 The packaged MCP and local bridges also read the same saved CLI config as a fallback, so a desktop MCP launch should not require pasting a token into Codex or Claude config after browser login. Guided setup verifies standards-compliant MCP initialize and tool discovery before it reports success.
 
 For Codex Desktop local runs, choose the runner globally and bind each project clone independently:
@@ -122,12 +123,12 @@ Prefer `launchchair setup codex` so the CLI writes native config and verifies MC
 
 ## What To Do First In A Fresh Chat
 
-1. If LaunchChair MCP tools are available, call `launchchair_heartbeat`.
-2. Call `launchchair_status` to confirm token, bridge, runner, and project context.
+1. Call `launchchair_status`. If login is required, call `launchchair_login`, present the approval URL, then poll `launchchair_login_status` at its returned interval.
+2. If paid access is required, present the returned upgrade URL and wait for the user to upgrade before resuming the blocked operation.
 3. If `LAUNCHCHAIR_PROJECT_ID` is blank and the user named a project, call `launchchair_list_projects` and select the matching project.
 4. If the user asks to create a new LaunchChair project, call `launchchair_create_project`.
-5. If the user clicked Run with agent in LaunchChair, call `launchchair_run_once`.
-6. If the user asks to advance the product workflow, call `launchchair_continue_project`.
+5. To pick up queued work or advance the workflow, call `launchchair_next_step`, execute its claimed prompt in the current host agent, and submit the result with `launchchair_complete_run`.
+6. Use `launchchair_run_once` or `executionMode=local_runner` only when the user explicitly requests a separate local runner.
 7. If LaunchChair asks for a user-choice bucket such as wedge, pricing, or feature direction, call `launchchair_select_choice`. Do not use generic SPEC_UPDATE apply for user-choice buckets.
 8. When the user asks for validation scores or wants to compare ideas, call `launchchair_get_scorecards`. Report validation scorecards separately from generated direction-option scores.
 
@@ -218,7 +219,7 @@ Avoid long explanations of local file searching when LaunchChair MCP tools are a
 Run a full project loop:
 
 ```text
-Call launchchair_continue_project with projectId, maxSteps, and optional stopPhaseKey.
+Call launchchair_next_step with projectId and optional stopPhaseKey, execute the claimed prompt with the host's tools, and call launchchair_complete_run. Repeat until the requested target or a genuine checkpoint.
 ```
 
 Create a project from a new idea:
@@ -233,18 +234,20 @@ Find a project by name:
 Call launchchair_list_projects with query set to the user-provided project name.
 ```
 
-Run one queued UI job:
+Claim one queued UI job for execution by the current agent:
 
 ```text
-Call launchchair_run_once.
+Call launchchair_next_step with projectId.
 ```
 
-Run one queued UI job from CLI:
+Run one queued UI job through an explicitly requested local runner:
 
 ```bash
 launchchair run-once
 ```
 
+Every MCP tool is also accessible through `launchchair call TOOL --json '{...}'` or `--input FILE`. Use `launchchair tools --json` for schemas. Tool results are JSON, tool errors exit nonzero, and token secrets remain in private files. Prefer host execution for agents with connected GitHub/Vercel/Supabase tools.
+
 Select a generated wedge:
 
 ```text
@@ -259,3 +262,15 @@ Call launchchair_select_choice with domain="wedge" and optionTitle or optionId.
 - Do not run production SQL without explicit user authorization and a known project ref.
 - Do not mark QA complete without matching evidence. For Feature projects, produce that evidence by running the repository-native or browser checks whenever possible.
 - Do not search the whole filesystem for LaunchChair source when the public docs and MCP tools are available.
+
+## MCP login and host execution
+
+The MCP can start without a token. Call `launchchair_login`, show the returned LaunchChair approval URL, and call `launchchair_login_status` after approval. Respect its poll interval. Tokens are stored privately in the local config and never returned to the conversation. Existing tokens need a fresh owner-approved login for `tokens.manage`. Use `launchchair_create_token` to save a scoped credential file, `launchchair_list_tokens` for redacted metadata, and `launchchair_revoke_token`/`launchchair_logout` for cleanup.
+
+Prefer `launchchair_next_step`, execute the claimed prompt in the current agent with its already-connected plugins, call `launchchair_complete_run`, and repeat. Do not spawn another model or local CLI unless explicitly requested (`executionMode=local_runner`). A waiting run is already claimed; poll it instead of executing it twice. Inspect forms/checklists with `launchchair_get_bucket`, save allowed patches with `launchchair_update_bucket`, and supply factual `executionEvidence` for setup and verification. Use `launchchair_get_starter` after validation to read the starter files and the host's GitHub/Vercel/Supabase tools to create and deploy the user's app. Bind the verified clone with `launchchair_bind_repository`. Use `stopPhaseKey=launch_sales` for the complete Product workflow.
+
+Preserve a supplied idea and specified requirements, even with low validation scores. `ideaIntent=preserve` is the default. Report risks and continue the requested work when no score gate was requested; never pivot merely to improve a score. Choose a generated direction consistent with the supplied idea. Only use `ideaIntent=explore` for explicit discovery or pivot requests.
+
+For “do not build until VERY high validation,” create candidates with `validationGate=very_high` (pain >=85, opportunity >=85, saturation <=30), validate through `market_validation`, and compare with `launchchair_compare_projects`. The gate is enforced on LaunchChair build/setup actions and cannot be weakened through generic mutations. Do not provision external resources until it passes. If no candidate qualifies, report the unmet thresholds honestly. Scores are research estimates, not a guarantee of market demand. Do not fabricate evidence or replace validation scores with direction-option scores.
+
+Research sources, competitor notes, Pexels assets, logo upload, form/checklist data, prompts, build cards, run management, and markdown exports are available as MCP tools. Tool descriptions distinguish data writes from actual external execution. Existing user authorization carries forward; ask only at a genuine missing authorization or information boundary.

package/README.md

@@ -4,24 +4,19 @@ LaunchChair Agent packages the LaunchChair CLI, MCP bridge, local bridge, and ru
 
 Use it when you want an agent to create or discover LaunchChair projects, run product phases, continue project loops, pick up `Run with agent` jobs from LaunchChair, or expose LaunchChair tools through MCP.
 
-## Install Locally For Testing
-
-From this package directory:
+## Install or update
 
 ```bash
-npm pack
-npm install -g ./launchchair-agent-*.tgz
-launchchair help
+npm install -g @launchchair/agent@latest
+launchchair --version
 launchchair doctor
 ```
 
-After publishing:
+Version 0.5.0 includes the expanded MCP, browser login, private token management, host-agent execution, idea preservation, and optional validation gates. Existing installations must update the package and restart their MCP connection to load the new tools.
 
-```bash
-npm install -g @launchchair/agent
-launchchair help
-launchchair doctor
-```
+After updating, run `launchchair setup codex --skip-login` or `launchchair setup claude --skip-login` to refresh the installed path and verify tool discovery. Then restart/reload that client. Your saved account login and project bindings remain in `~/.launchchair/config.json`. Older tokens still work within their existing scopes; run `launchchair login` again with workspace-owner approval if you need the new `tokens.manage` scope.
+
+For local release testing, run `npm pack ./packages/launchchair-agent --pack-destination /tmp` from the repository root and install the resulting tarball into an isolated npm prefix before publishing.
 
 ## Login
 
@@ -49,7 +44,7 @@ Tokens are masked in CLI output. Do not paste real tokens into public docs, scre
 
 ## Guided Setup
 
-Use `setup` as the easiest path. It starts browser login when no token is saved yet, writes the global MCP config for your agent, creates isolated per-project workspaces, and then proves the server can complete MCP `initialize` and `tools/list` before reporting success.
+Use `setup` as the easiest path. It starts browser login when no token is saved yet, writes the global MCP config for your agent, creates isolated per-project workspaces, and then verifies MCP discovery and an authenticated status call before reporting authenticated success. Unauthenticated discovery is reported separately as login required.
 
 Codex Desktop:
 
@@ -118,6 +113,29 @@ launchchair mcp-config claude
 launchchair install-agent-md --cwd /absolute/path/to/repo
 ```
 
+## Use any MCP tool from the terminal
+
+`tools` discovers the same catalog as your MCP connection (47 tools when authenticated). `call` uses the bundled MCP implementation, including its login, permission checks, private credential storage, and host-execution defaults. Tool errors return a nonzero exit status and preserve details such as an upgrade URL.
+
+```bash
+launchchair tools --json
+launchchair call status
+launchchair call next_step --json '{"projectId":"PROJECT_UUID"}'
+launchchair call complete_run --input completed-run.json
+launchchair call list_tokens
+launchchair call create_token --json '{"name":"Build agent","scopes":["spec.read"]}'
+```
+
+Tool names work with or without the `launchchair_` prefix. Use `--input -` to read JSON arguments from stdin. `next_step` returns a claimed prompt for your current agent to execute with its connected plugins; it does not start another agent. `complete_run` submits the actual result and execution evidence. Token creation returns a private credential-file path, never the secret in terminal output.
+
+Project creation preserves a supplied idea by default, even when validation is low. Only request exploration and a score gate when that matches the user's intent:
+
+```bash
+launchchair create --name "Groomer candidate" --one-liner "Reduce missed appointments" --idea-intent explore --validation-gate very_high --save-project
+```
+
+The gate requires pain >=85, opportunity >=85, and saturation <=30 before build/setup. For custom thresholds or the full Feature input schema, use `launchchair call create_project` or `launchchair call create_feature_project` with JSON arguments.
+
 Feature projects can be created and planned from the CLI for every authenticated LaunchChair workspace:
 
 ```bash
@@ -158,7 +176,7 @@ launchchair mcp-config claude
 
 The recommended config launches the MCP server through the exact Node executable and CLI file path generated by `launchchair setup` or `launchchair mcp-config`. It also pins `LAUNCHCHAIR_CONFIG_DIR` to the exact directory used by `launchchair login`, so Codex and Claude users do not need to paste tokens into MCP config after browser login—even when the desktop app starts with a different home or shell environment. The server uses standard newline-delimited JSON-RPC over stdio, as required by MCP clients.
 
-Use `LAUNCHCHAIR_AGENT_TOKEN` only as a manual fallback when you skip `launchchair login`, need a per-client token override, or your desktop app cannot read the saved CLI config. If you use a desktop custom MCP form, run `launchchair mcp-config codex --ui-fields` or `launchchair mcp-config claude --ui-fields` and paste the printed command, each argument, env vars, and working directory exactly as shown.
+Use `LAUNCHCHAIR_AGENT_TOKEN` as a manual fallback when you skip `launchchair login` or your desktop app cannot read the saved config. A saved browser login takes precedence over stale environment credentials. Logout disables both CLI and MCP authentication until another login. For a separate per-client account, use a separate `LAUNCHCHAIR_CONFIG_DIR`. If you use a desktop custom MCP form, run `launchchair mcp-config codex --ui-fields` or `launchchair mcp-config claude --ui-fields` and paste the printed command, each argument, env vars, and working directory exactly as shown.
 
 ## Local Bridge
 
@@ -207,3 +225,15 @@ This package includes `AGENTS.md`. Fresh Codex, Claude, and Hermes chats should
 - MCP docs: https://www.launchchair.io/docs/mcp
 - Agent API docs: https://www.launchchair.io/docs/agent-api
 - Machine-readable catalog: https://www.launchchair.io/api/agent/v1/docs
+
+## MCP login and host execution
+
+The MCP can start without a token. Call `launchchair_login`, show the returned LaunchChair approval URL, and call `launchchair_login_status` after approval. Respect its poll interval. Tokens are stored privately in the local config and never returned to the conversation. Existing tokens need a fresh owner-approved login for `tokens.manage`. Use `launchchair_create_token` to save a scoped credential file, `launchchair_list_tokens` for redacted metadata, and `launchchair_revoke_token`/`launchchair_logout` for cleanup.
+
+Prefer `launchchair_next_step`, execute the claimed prompt in the current agent with its already-connected plugins, call `launchchair_complete_run`, and repeat. Do not spawn another model or local CLI unless explicitly requested (`executionMode=local_runner`). A waiting run is already claimed; poll it instead of executing it twice. Inspect forms/checklists with `launchchair_get_bucket`, save allowed patches with `launchchair_update_bucket`, and supply factual `executionEvidence` for setup and verification. Use `launchchair_get_starter` after validation to read the starter files and the host's GitHub/Vercel/Supabase tools to create and deploy the user's app. Bind the verified clone with `launchchair_bind_repository`. Use `stopPhaseKey=launch_sales` for the complete Product workflow.
+
+Preserve a supplied idea and specified requirements, even with low validation scores. `ideaIntent=preserve` is the default. Report risks and continue the requested work when no score gate was requested; never pivot merely to improve a score. Choose a generated direction consistent with the supplied idea. Only use `ideaIntent=explore` for explicit discovery or pivot requests.
+
+For “do not build until VERY high validation,” create candidates with `validationGate=very_high` (pain >=85, opportunity >=85, saturation <=30), validate through `market_validation`, and compare with `launchchair_compare_projects`. The gate is enforced on LaunchChair build/setup actions and cannot be weakened through generic mutations. Do not provision external resources until it passes. If no candidate qualifies, report the unmet thresholds honestly. Scores are research estimates, not a guarantee of market demand. Do not fabricate evidence or replace validation scores with direction-option scores.
+
+Research sources, competitor notes, Pexels assets, logo upload, form/checklist data, prompts, build cards, run management, and markdown exports are available as MCP tools. Tool descriptions distinguish data writes from actual external execution. Existing user authorization carries forward; ask only at a genuine missing authorization or information boundary.

package/launchchair-cli.mjs

@@ -20,7 +20,7 @@ import {
   unbindProjectWorkspace,
 } from "./project-workspace.mjs";
 
-const VERSION = "0.4.12";
+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()
@@ -109,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;
@@ -171,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
@@ -183,6 +190,9 @@ 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 global CLI/MCP setup with isolated project workspaces
   bind --project-id ID --cwd PATH Bind one LaunchChair project to a verified local Git clone
@@ -202,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
@@ -245,7 +257,7 @@ 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              Legacy candidate only; verified per project before use
@@ -255,6 +267,11 @@ 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}
 `);
@@ -308,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;
 }
@@ -331,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;
 }
@@ -391,6 +417,8 @@ async function login(args) {
     }
     saveConfig({
       agentToken: incomingToken,
+      mcpLoggedOut: false,
+      mcpPreferSavedToken: true,
       baseUrl: incomingBaseUrl ?? baseUrl(),
       projectId: incomingProjectId || defaultProjectId() || undefined,
     });
@@ -434,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.");
@@ -449,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;
     }
@@ -460,6 +490,8 @@ async function login(args) {
       print("");
       saveConfig({
         agentToken: poll.token,
+        mcpLoggedOut: false,
+        mcpPreferSavedToken: true,
         baseUrl: baseUrl(),
         projectId: incomingProjectId || defaultProjectId() || undefined,
       });
@@ -478,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.");
   }
 }
 
@@ -606,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)) {
@@ -664,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");
@@ -876,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";
 }
@@ -885,13 +1020,11 @@ function tomlString(value) {
 }
 
 function mcpEnvForTarget(target, options = {}) {
-  const includeTokenPlaceholder = options.includeTokenPlaceholder !== false;
   const details = targetDetails(target || "codex");
   const projectId = defaultProjectId();
   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,
@@ -916,6 +1049,7 @@ function verifyMcpServer(target, timeoutMs = 20_000) {
       stdio: ["pipe", "pipe", "pipe"],
     });
     let settled = false;
+    let discoveredTools = [];
     let stdout = "";
     let stderr = "";
 
@@ -966,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);
         }
       }
     });
@@ -1286,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.",
@@ -1326,6 +1479,8 @@ async function setup(args) {
     }
     saveConfig({
       agentToken: incomingToken,
+      mcpLoggedOut: false,
+      mcpPreferSavedToken: true,
       baseUrl: incomingBaseUrl ?? baseUrl(),
       projectId: incomingProjectId || defaultProjectId() || undefined,
     });
@@ -1412,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) {
@@ -1455,7 +1610,8 @@ 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.");
   }
@@ -1479,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();
@@ -1490,6 +1647,8 @@ 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);

package/local-bridge.mjs

@@ -18,7 +18,7 @@ import { fileURLToPath } from "node:url";
 import { resolveProjectWorkspace } from "./project-workspace.mjs";
 import { buildRunnerCommand, parseRunnerCommand } from "./runner-command.mjs";
 
-const VERSION = "0.4.12";
+const VERSION = "0.5.0";
 const CLIENT_TYPES = ["codex", "chatgpt", "claude", "claude_code", "other"];
 const AGENT_SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CONFIG_DIR = process.env.LAUNCHCHAIR_CONFIG_DIR?.trim()
@@ -402,6 +402,7 @@ async function executeRunner(run) {
       stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
+        ...(resolved.workspace.source === "isolated" && run?.runnerWorkspace?.requiresRepository !== true ? { LC_AGENT_CODEX_SKIP_GIT_CHECK: "1" } : {}),
         LC_AGENT_RUN_ID: String(run.id ?? ""),
         LC_AGENT_PROJECT_ID: String(run.projectId ?? ""),
         LC_AGENT_PHASE_KEY: String(run.phaseKey ?? ""),

package/mcp-bridge-server.mjs

@@ -19,8 +19,9 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { resolveProjectWorkspace } from "./project-workspace.mjs";
 import { buildRunnerCommand, parseRunnerCommand } from "./runner-command.mjs";
+import { createMcpCapabilities, EXTRA_MCP_TOOLS, MCP_WORKFLOW_INSTRUCTIONS, VALIDATION_GATE_SCHEMA } from "./mcp-capabilities.mjs";
 
-const VERSION = "0.4.12";
+const VERSION = "0.5.0";
 const SERVER_NAME = "launchchair-agent-mcp";
 const AGENT_SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CONFIG_DIR = process.env.LAUNCHCHAIR_CONFIG_DIR?.trim()
@@ -108,7 +109,7 @@ function builtInRunnerCommand(target) {
 }
 
 const config = {
-  baseUrl: env("LAUNCHCHAIR_BASE_URL", savedConfigValue("baseUrl", "http://localhost:3000")).replace(/\/+$/, ""),
+  baseUrl: env("LAUNCHCHAIR_BASE_URL", savedConfigValue("baseUrl", "https://www.launchchair.io")).replace(/\/+$/, ""),
   token: env("LAUNCHCHAIR_AGENT_TOKEN", env("LAUNCHCHAIR_API_KEY", savedConfigValue("agentToken"))),
   projectId: env("LAUNCHCHAIR_PROJECT_ID", savedConfigValue("projectId")) || null,
   clientName: env("LC_AGENT_CLIENT_NAME", "MCP Bridge"),
@@ -135,70 +136,52 @@ const config = {
   },
 };
 
-if (!config.token) {
-  // eslint-disable-next-line no-console
-  console.error(
-    `Missing LaunchChair Agent API token. Run "launchchair login" or set LAUNCHCHAIR_AGENT_TOKEN. Checked ${CONFIG_PATH}.`,
-  );
-  process.exit(1);
-}
-
-if (
-  !config.mockResponse &&
-  !config.runnerCommands.generic &&
-  !config.runnerCommands.gpt &&
-  !config.runnerCommands.codex &&
-  !config.runnerCommands.chatgpt &&
-  !config.runnerCommands.claude &&
-  !config.runnerCommands.codexTarget &&
-  !config.runnerCommands.claudeCode
-) {
-  // eslint-disable-next-line no-console
-  console.error(
-    "No runner command configured for MCP bridge. Set LC_AGENT_RUNNER_CMD* or use the built-in Codex/Claude Code runners; ChatGPT/Claude API fallbacks require provider API keys.",
-  );
-  process.exit(1);
-}
+let statusPromise = null;
+let initialized = false;
+const capabilities = createMcpCapabilities({ config, configPath: CONFIG_PATH, api, resolveProjectId, onAuthChange: () => { statusPromise = null; if (initialized) writeMessage({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }); } });
 
 async function api(path, { method = "GET", body } = {}) {
+  const token = capabilities.currentToken();
+  if (!token) {
+    const error = new Error("Login required. Call launchchair_login and complete browser approval.");
+    error.status = 401;
+    error.payload = { code: "login_required", nextTool: "launchchair_login" };
+    throw error;
+  }
   const response = await fetch(`${config.baseUrl}${path}`, {
     method,
     headers: {
-      Authorization: `Bearer ${config.token}`,
+      Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
     },
     body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(30_000),
   });
 
-  let payload = null;
-  try {
-    payload = await response.json();
-  } catch (_error) {
-    payload = null;
-  }
+  const raw = await response.text();
+  let payload;
+  try { payload = raw ? JSON.parse(raw) : null; } catch { payload = { content: raw, contentType: response.headers.get("content-type") }; }
 
   if (!response.ok) {
     const err = new Error(`HTTP ${response.status}: ${String(payload?.error ?? response.statusText ?? "Request failed")}`);
     err.status = response.status;
-    err.payload = payload;
+    err.payload = response.status === 401 ? { ...payload, code: "login_required", nextTool: "launchchair_login" } : payload;
     err.retryAfterSeconds = Number.parseInt(response.headers.get("retry-after") ?? "", 10) || null;
     throw err;
   }
   return payload;
 }
 
-let statusPromise = null;
-
 function loadStatus() {
   if (!statusPromise) {
-    statusPromise = api("/api/agent/v1").catch(() => null);
+    statusPromise = api("/api/agent/v1").catch(() => { statusPromise = null; return null; });
   }
   return statusPromise;
 }
 
 function serverInstructions(status) {
   const featureInstructions = String(status?.capabilities?.mcpServerInstructions ?? "").trim();
-  return featureInstructions ? `${BASE_SERVER_INSTRUCTIONS} ${featureInstructions}` : BASE_SERVER_INSTRUCTIONS;
+  return `${BASE_SERVER_INSTRUCTIONS} ${featureInstructions} ${MCP_WORKFLOW_INSTRUCTIONS}`;
 }
 
 function targetForRun(run) {
@@ -291,6 +274,7 @@ async function executeRunner(run) {
         LC_AGENT_PROMPT_MODE: String(run.promptMode ?? ""),
         LC_AGENT_RUN_TYPE: String(run.runType ?? ""),
         [workspaceEnvName]: workspace.path,
+        ...(workspace.source === "isolated" && run?.runnerWorkspace?.requiresRepository !== true ? { LC_AGENT_CODEX_SKIP_GIT_CHECK: "1" } : {}),
       },
     });
     let stdout = "";
@@ -347,6 +331,7 @@ async function claimNextRun(args = {}) {
     method: "POST",
     body: {
       projectId,
+      ...(args.runId ? { runId: String(args.runId) } : {}),
       clientName: String(args.clientName ?? "").trim() || config.clientName,
       clientType: normalizeTarget(args.clientType ?? config.clientType, "other"),
       clientVersion: String(args.clientVersion ?? "").trim() || config.clientVersion,
@@ -600,15 +585,19 @@ async function continueProjectLoop(args = {}) {
       break;
     }
 
-    const run = loop.run
-      ? { ...loop.run, runnerWorkspace: loop.runnerWorkspace ?? runnerWorkspaceContext }
-      : null;
-    if (!run?.id || !run?.prompt) {
-      final = loop;
+    const claimed = loop.run?.id ? await claimNextRun({ ...args, projectId, runId: loop.run.id }) : null;
+    if (!claimed) {
+      final = { ...loop, run: loop.run?.id ? { id: loop.run.id } : null, message: "Run already claimed; do not execute it again." };
+      break;
+    }
+    const run = { ...claimed, runnerWorkspace: claimed.runnerWorkspace ?? loop.runnerWorkspace ?? runnerWorkspaceContext };
+    let execution;
+    try { execution = await executeRunner(run); }
+    catch (error) {
+      await completeRun({ runId: run.id, status: "failed", error: error.message, resultRaw: error.stdout || error.stderr || "" });
+      final = { status: "stopped_after_failed_step", projectId, runId: run.id, message: error.message };
       break;
     }
-
-    const execution = await executeRunner(run);
     const stdout = String(execution.stdout ?? "").trim();
     const stderr = String(execution.stderr ?? "").trim();
     const output = stdout || stderr;
@@ -695,6 +684,7 @@ async function createProject(args = {}) {
   delete createArgs.maxSteps;
   delete createArgs.fullLoop;
   delete createArgs.buildMaxSteps;
+  delete createArgs.executionMode;
   const body = {
     ...createArgs,
     name: String(args.name ?? args.projectName ?? "").trim(),
@@ -721,6 +711,8 @@ async function createProject(args = {}) {
     return payload;
   }
 
+  if (args.executionMode !== "local_runner") return { ...payload, next: { ...payload.next, tool: "launchchair_next_step", arguments: { projectId, stopPhaseKey: "build", completionTarget: fullLoop ? "phase_complete" : "build_board_ready" }, execution: "host", instructions: MCP_WORKFLOW_INSTRUCTIONS } };
+
   const planning = await continueProjectLoop({
     projectId,
     stopPhaseKey: "build",
@@ -999,8 +991,8 @@ function annotateTool(tool) {
     ...tool,
     annotations: {
       ...(tool.annotations ?? {}),
-      readOnlyHint: READ_ONLY_TOOLS.has(tool.name),
-      destructiveHint: false,
+      readOnlyHint: tool.annotations?.readOnlyHint ?? READ_ONLY_TOOLS.has(tool.name),
+      destructiveHint: tool.annotations?.destructiveHint ?? false,
       openWorldHint: true,
     },
   };
@@ -1016,7 +1008,12 @@ function mergeToolOverrides(baseTools, overrides) {
       merged.push(override);
     }
   }
-  return merged.map(annotateTool);
+  return merged.map((tool) => {
+    if (["launchchair_create_project", "launchchair_create_feature_project"].includes(tool.name)) tool = { ...tool, inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, idempotencyKey: { type: "string" }, ideaIntent: { type: "string", enum: ["preserve", "explore"], default: "preserve" }, validationGate: VALIDATION_GATE_SCHEMA, executionMode: { type: "string", enum: ["host", "local_runner"], default: "host" } } } };
+    if (tool.name === "launchchair_claim_next_run") tool = { ...tool, inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, runId: { type: "string" } } } };
+    if (tool.name === "launchchair_continue_project") tool = { ...tool, description: "Advance one step in the current host agent by default. Only use executionMode=local_runner to spawn a separate local CLI.", inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, executionMode: { type: "string", enum: ["host", "local_runner"], default: "host" } } } };
+    return annotateTool(tool);
+  });
 }
 
 function writeMessage(obj) {
@@ -1059,7 +1056,7 @@ async function handleRpc(request) {
     writeResult(id, {
       protocolVersion: "2024-11-05",
       capabilities: {
-        tools: {},
+        tools: { listChanged: true },
       },
       serverInfo: {
         name: SERVER_NAME,
@@ -1071,6 +1068,7 @@ async function handleRpc(request) {
   }
 
   if (method === "notifications/initialized") {
+    initialized = true;
     return;
   }
 
@@ -1079,7 +1077,7 @@ async function handleRpc(request) {
     const overrides = Array.isArray(status?.capabilities?.mcpToolOverrides)
       ? status.capabilities.mcpToolOverrides
       : [];
-    const tools = mergeToolOverrides(MCP_TOOLS, overrides);
+    const tools = mergeToolOverrides([...MCP_TOOLS, ...EXTRA_MCP_TOOLS], overrides);
     writeResult(id, { tools });
     return;
   }
@@ -1089,9 +1087,13 @@ async function handleRpc(request) {
     const toolName = String(params.name ?? "");
     const args = typeof params.arguments === "object" && params.arguments ? params.arguments : {};
     try {
+      if (EXTRA_MCP_TOOLS.some((tool) => tool.name === toolName)) {
+        writeResult(id, textResult(await capabilities.dispatch(toolName, args)));
+        return;
+      }
       if (toolName === "launchchair_status") {
         const status = await api("/api/agent/v1");
-        writeResult(id, textResult(status));
+        writeResult(id, textResult({ ...status, authenticated: true }));
         return;
       }
       if (toolName === "launchchair_create_project") {
@@ -1140,7 +1142,7 @@ async function handleRpc(request) {
         return;
       }
       if (toolName === "launchchair_continue_project") {
-        const payload = await continueProjectLoop(args);
+        const payload = args.executionMode === "local_runner" ? await continueProjectLoop(args) : await capabilities.dispatch("launchchair_next_step", { ...args, executionMode: undefined, maxSteps: undefined });
         writeResult(id, textResult(payload));
         return;
       }

package/mcp-capabilities.mjs

@@ -0,0 +1,227 @@
+import { readFileSync, writeFileSync, mkdirSync, renameSync, chmodSync } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { bindProjectWorkspace } from "./project-workspace.mjs";
+
+const string = { type: "string" };
+const object = { type: "object", additionalProperties: true };
+const patch = { type: "array", items: { type: "object", properties: { op: { type: "string", enum: ["add", "replace", "remove"] }, path: string, value: {} }, required: ["op", "path"], additionalProperties: false } };
+const project = { projectId: string, projectName: string };
+const bucket = { ...project, phaseKey: string, bucketKey: string };
+const card = { ...project, cardId: string };
+export const VALIDATION_GATE_SCHEMA = { anyOf: [{ type: "string", enum: ["very_high"] }, { type: "object", properties: { minPain: { type: "number", minimum: 0, maximum: 100 }, minOpportunity: { type: "number", minimum: 0, maximum: 100 }, maxSaturation: { type: "number", minimum: 0, maximum: 100 } }, additionalProperties: false }] };
+export const MCP_WORKFLOW_INSTRUCTIONS = "Prefer launchchair_next_step: execute the returned claimed prompt in THIS host agent using its existing research, repository, GitHub, Vercel and Supabase tools, then launchchair_complete_run and repeat. Do not start a second model/CLI unless the user requests local-runner execution. The server cannot inherit or call the host's other plugins itself. Preserve a supplied idea by default, including when scores are low; report risks without rewriting the source problem, audience, solution or specified requirements. Only use ideaIntent=explore when the user requests discovery/pivots. Validation gates are opt-in: do not impose a gate on an established idea unless the user requested one. For 'VERY high' scores use validationGate=very_high (pain>=85, opportunity>=85, saturation<=30). Research real evidence, create separate candidates, finish validation and compare LaunchChair scorecards, never inflate evidence or use direction-option scores as validation. Stop at a failed gate. If no candidate qualifies, report that honestly. Use connected infrastructure plugins only after the gate passes, save their verified results with update_bucket plus executionEvidence, bind the repository, and continue. Present actual authorization/production SQL checkpoints; reuse existing plugin authorization. Do not claim external actions were done without evidence. Complete runnable QA yourself and record results; ask for human checks only when truly necessary. Never disclose bearer tokens or private login device codes.";
+
+function tool(name, description, properties = {}, required = [], readOnly = false) {
+  return { name: `launchchair_${name}`, description, inputSchema: { type: "object", properties, required, additionalProperties: false }, annotations: { readOnlyHint: readOnly, destructiveHint: ["revoke_token", "cancel_run", "write_competitor_note", "upload_logo"].includes(name), openWorldHint: true } };
+}
+
+const definitions = [
+  ["list_competitor_notes", "Read competitor research notes in the current project.", project, [], "GET", "/competitor-notes"],
+  ["write_competitor_note", "Create, update, or delete a competitor note. Updating/deleting requires authorship or active owner access.", { ...project, operation: { type: "string", enum: ["create", "update", "delete"] }, noteId: string, competitorKey: string, competitorName: string, content: string }, ["operation"], "POST", "/competitor-notes"],
+  ["upload_logo", "Upload a PNG/WebP logo (base64, up to 1 MiB) or remove the existing logo with remove=true. Use the host's image tools to create the logo first.", { ...project, contentBase64: string, mimeType: { type: "string", enum: ["image/png", "image/webp"] }, generationPrompt: string, remove: { type: "boolean" } }, [], "POST", "/logo"],
+  ["research_sources", "Fetch LaunchChair research sources: Hacker News search, Product Hunt ranked posts, or a public HTTPS RSS feed (including Reddit/Indie Hackers). Returns source material without changing the idea. Inspect evidence before saving findings via bucket tools.", { ...project, source: { type: "string", enum: ["hn", "product_hunt", "rss"] }, query: string, url: string, limit: { type: "integer", minimum: 1, maximum: 40 } }, ["source"], "POST", "/research"],
+  ["search_media", "Search LaunchChair's Pexels integration for photos/videos. Retain source and creator attribution; save selected assets through the appropriate bucket.", { ...project, query: string, kind: { type: "string", enum: ["photo", "video"] }, limit: { type: "integer", minimum: 1, maximum: 40 } }, ["query"], "POST", "/media"],
+  ["get_starter", "Read the private LaunchChair starter manifest, then download batches of files (base64) using paths and treeSha. Paid, scoped, and validation-gated. Create/commit/deploy the repository with the host GitHub/Vercel/Supabase tools; no provider credentials are transferred to LaunchChair.", { ...project, paths: { type: "array", items: string, minItems: 1, maxItems: 20 }, treeSha: string }, [], "POST", "/starter"],
+  ["get_spec", "Read the normalized project spec, validation scores and saved idea intent.", project, [], "GET", "/spec"],
+  ["update_spec", "Advanced guarded spec patch. Requires spec.write; default tokens use bucket-specific tools. Cannot change idea intent or validation policy.", { ...project, patch }, ["patch"], "PATCH", "/spec"],
+  ["list_buckets", "List all phases/buckets and progress.", project, [], "GET", "/buckets"],
+  ["get_bucket", "Read a bucket's data, allowed patch paths and evidence requirements before editing.", bucket, ["phaseKey", "bucketKey"], "GET", "/buckets/:phaseKey/:bucketKey"],
+  ["update_bucket", "Save form/checklist data using allowed JSON Patch paths, or update status. For setup and checklists supply factual executionEvidence {source,checkedAt,summary} from the host's connected plugins/tests. Never store credentials. Read get_bucket first. Does not provision infrastructure itself.", { ...bucket, patch, status: { type: "string", enum: ["not_started", "in_progress", "done"] }, executionEvidence: object }, ["phaseKey", "bucketKey"], "PATCH", "/buckets/:phaseKey/:bucketKey"],
+  ["get_bucket_prompt", "Read a bucket's compiled prompt for execution by the current host agent. Brand supports variant=tagline or logo; campaign_builder requires campaignId. Save generated form output with update_bucket.", { ...bucket, variant: { type: "string", enum: ["tagline", "logo"] }, campaignId: string }, ["phaseKey", "bucketKey"], "GET", "/buckets/:phaseKey/:bucketKey/prompt"],
+  ["apply_bucket_update", "Apply validated SPEC_UPDATE JSON Patch for a prompt bucket. Prefer complete_run for claimed runs so validation/remediation executes.", { ...bucket, patch, compiledPrompt: string, templateKey: string, pastedResponse: string }, ["phaseKey", "bucketKey", "patch"], "POST", "/buckets/:phaseKey/:bucketKey/apply-spec-update"],
+  ["get_build_cards", "Inspect build cards, dependencies, SQL actions and QA checkpoints.", project, [], "GET", "/build-cards"],
+  ["update_build_card", "Record build-card status, acceptance, SQL completion and QA results only after verification. Supply executionEvidence {source,checkedAt,summary} when completing a card or checking results. This records results, it does not execute SQL or tests.", { ...card, status: { type: "string", enum: ["To Do", "In Progress", "Needs Review", "Done"] }, notes: string, acceptanceStatus: object, testingNotesStatus: object, sqlActionsStatus: object, executionEvidence: object }, ["cardId", "status"], "PATCH", "/build-cards/:cardId"],
+  ["get_build_card_prompt", "Read the compiled build-card prompt. Requires a passing validation gate when configured.", card, ["cardId"], "GET", "/build-cards/:cardId/prompt"],
+  ["apply_build_card_run", "Apply CHANGELOG_JSON/REQUIRES from an executed build card. Use the API payload contract returned by the catalog.", { ...card, payload: object }, ["cardId", "payload"], "POST", "/build-cards/:cardId/apply-run"],
+  ["export_mvp_spec", "Export the AI-ready MVP markdown specification.", project, [], "GET", "/exports/mvp-ai-spec"],
+  ["export_phase", "Export a phase synthesis as markdown.", { ...project, phaseKey: string }, ["phaseKey"], "GET", "/exports/phase/:phaseKey"],
+  ["get_runner_workspace", "Read expected repository and workspace requirements.", project, [], "GET", "/runner-workspace"],
+  ["get_validation_gate", "Evaluate the saved validation gate using current calculated LaunchChair scores.", project, [], "GET", "/validation-gate"],
+  ["set_validation_gate", "Set or tighten an explicitly user-requested gate. Does not authorize changing the user's idea. An existing gate cannot be weakened by this tool.", { ...project, validationGate: VALIDATION_GATE_SCHEMA }, ["validationGate"], "POST", "/validation-gate"],
+  ["list_runs", "List recent runs belonging to this token and project.", project, [], "GET", "/runs"],
+  ["queue_run", "Queue a specific prompt bucket or build-card run, including research reruns. Then claim it and execute in this host agent; complete_run applies and validates the result.", { ...bucket, cardId: string }, [], "POST", "/runs"],
+];
+
+export const EXTRA_MCP_TOOLS = [
+  ...definitions.map(([name, description, properties, required, method]) => tool(name, description, properties, required, method === "GET")),
+  tool("login", "Start browser-assisted LaunchChair login/token creation without an existing token. Return the existing LaunchChair approval URL for the user; then poll login_status. No password or token is requested in chat.", { tokenName: string, restart: { type: "boolean" } }),
+  tool("login_status", "Poll the pending browser approval once. Respect retryAfterSeconds. On approval save the token privately and authenticate this MCP session immediately.", {}),
+  tool("logout", "Disconnect this MCP and remove its saved token. Optionally revoke the current token on the server first.", { revoke: { type: "boolean", default: false } }),
+  tool("list_tokens", "List redacted tokens. Requires fresh owner authorization with tokens.manage and workspace-wide access.", {}, [], true),
+  tool("create_token", "Create a token with no more privileges/lifetime than the current token. Store its secret in a private local file and return only metadata/path. Optionally activate it for this MCP. Requires tokens.manage from owner-approved login.", { name: string, projectIds: { type: "array", items: string }, scopes: { type: "array", items: string }, expiresAt: string, activate: { type: "boolean", default: false } }, ["name"]),
+  tool("revoke_token", "Revoke a token in the authorized workspace. Revoking the current token disconnects this MCP.", { tokenId: string }, ["tokenId"]),
+  tool("get_run", "Read a run's status and output. Do not execute a run already claimed by another worker.", { runId: string }, ["runId"], true),
+  tool("cancel_run", "Cancel a queued/running run so further results cannot be applied. Stop any host process separately.", { runId: string }, ["runId"]),
+  tool("next_step", "Queue and atomically claim ONE next step for THIS host agent, without spawning a separate runner. Execute its prompt with your own tools/plugins, complete_run, then call again. Returns forms/setup/gate checkpoints when applicable. Set stopPhaseKey=launch_sales for the entire Product workflow, or market_validation for research only.", { ...project, stopPhaseKey: string, completionTarget: { type: "string", enum: ["phase_complete", "build_board_ready"] }, ideaSnapshot: object, choiceSelections: { type: "array", items: object }, agentSetup: object }, []),
+  tool("bind_repository", "Bind a local clone after checking its Git origin against the repository saved in LaunchChair. No cloning or infrastructure provisioning occurs.", { ...project, cwd: string }, ["cwd"]),
+  tool("compare_projects", "Compare up to 20 candidate ideas using calculated validation scores and requested thresholds. Never mutates ideas or inflates scores; returns qualifying candidates separately.", { projectIds: { type: "array", items: string, minItems: 1, maxItems: 20 }, validationGate: VALIDATION_GATE_SCHEMA }, ["projectIds"], true),
+  tool("research_opportunities", "Get a bounded research workflow for an explicitly exploratory user request. Execute the research using this host's search tools, then create and validate separate LaunchChair candidates. This tool itself does not research or create projects.", { audience: string, maxCandidates: { type: "integer", minimum: 1, maximum: 20, default: 5 }, validationGate: VALIDATION_GATE_SCHEMA }, ["audience"], true),
+];
+
+export function createMcpCapabilities({ config, configPath, api, resolveProjectId, onAuthChange }) {
+  let sessionToken;
+  let pollInFlight = false;
+  let authEpoch = 0;
+  const projectSteps = new Set();
+  const configDir = path.dirname(configPath);
+  function readConfig() { try { const value = JSON.parse(readFileSync(configPath, "utf8")); return value && typeof value === "object" && !Array.isArray(value) ? value : {}; } catch { return {}; } }
+  function saveConfig(changes) {
+    const next = { ...readConfig(), ...changes };
+    for (const key of Object.keys(next)) if (next[key] === undefined) delete next[key];
+    mkdirSync(configDir, { recursive: true, mode: 0o700 });
+    const temporary = `${configPath}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+    renameSync(temporary, configPath);
+    chmodSync(configPath, 0o600);
+  }
+  function currentToken() {
+    if (sessionToken !== undefined) return sessionToken;
+    const saved = readConfig();
+    if (saved.mcpLoggedOut === true) return "";
+    if (saved.mcpPreferSavedToken === true && saved.agentToken) return saved.agentToken;
+    return process.env.LAUNCHCHAIR_AGENT_TOKEN?.trim() || process.env.LAUNCHCHAIR_API_KEY?.trim() || saved.agentToken || "";
+  }
+  function activate(token) {
+    saveConfig({ agentToken: token, baseUrl: config.baseUrl, mcpLoggedOut: false, mcpPreferSavedToken: true, pendingMcpLogin: undefined });
+    sessionToken = token;
+    onAuthChange();
+  }
+  function disconnect() {
+    authEpoch += 1;
+    saveConfig({ agentToken: undefined, pendingMcpLogin: undefined, mcpLoggedOut: true });
+    sessionToken = "";
+    onAuthChange();
+  }
+  async function publicRequest(endpoint, body) {
+    const response = await fetch(`${config.baseUrl}${endpoint}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(30_000) });
+    const payload = await response.json();
+    if (response.status === 429) return { status: "pending", retryAfterSeconds: Math.max(5, Number(response.headers.get("retry-after")) || 10) };
+    if (!response.ok) {
+      const error = new Error(String(payload.error || payload.status || `HTTP ${response.status}`));
+      error.status = response.status;
+      throw error;
+    }
+    return payload;
+  }
+  async function loginStatus() {
+    const saved = readConfig().pendingMcpLogin;
+    if (!saved) return { status: currentToken() ? "authenticated" : "not_started", nextTool: currentToken() ? "launchchair_status" : "launchchair_login" };
+    if (Date.now() >= saved.expiresAt) { saveConfig({ pendingMcpLogin: undefined }); return { status: "expired", nextTool: "launchchair_login" }; }
+    if (pollInFlight || Date.now() < (saved.nextPollAt || 0)) return { status: "pending", retryAfterSeconds: Math.max(1, Math.ceil(((saved.nextPollAt || Date.now() + 5000) - Date.now()) / 1000)) };
+    pollInFlight = true;
+    const epoch = authEpoch;
+    try {
+      const result = await publicRequest("/api/agent/v1/cli-login/poll", { deviceCode: saved.deviceCode });
+      if (epoch !== authEpoch || readConfig().pendingMcpLogin?.deviceCode !== saved.deviceCode) return { status: "cancelled", nextTool: "launchchair_login" };
+      if (result.status === "approved" && result.token) {
+        activate(result.token);
+        return { status: "authenticated", tokenRecord: result.tokenRecord, nextTool: "launchchair_status", message: "Login approved; token saved privately. MCP is ready without restarting." };
+      }
+      const retryAfterSeconds = Math.max(5, Number(result.retryAfterSeconds || result.interval) || 5);
+      saveConfig({ pendingMcpLogin: { ...saved, nextPollAt: Date.now() + retryAfterSeconds * 1000 } });
+      return { status: result.status || "pending", retryAfterSeconds };
+    } catch (error) {
+      if ([400, 403, 404, 410].includes(error.status)) saveConfig({ pendingMcpLogin: undefined });
+      throw error;
+    } finally { pollInFlight = false; }
+  }
+  async function dispatch(name, args) {
+    if (name === "launchchair_login") {
+      let pending = readConfig().pendingMcpLogin;
+      if (!pending || pending.expiresAt <= Date.now() || args.restart === true) {
+        const epoch = ++authEpoch;
+        const started = await publicRequest("/api/agent/v1/cli-login/start", { clientName: "LaunchChair MCP", tokenName: args.tokenName || "LaunchChair MCP" });
+        if (epoch !== authEpoch) return { status: "cancelled", nextTool: "launchchair_login" };
+        if (!started.deviceCode || !started.verificationUriComplete) return { status: "rate_limited", retryAfterSeconds: started.retryAfterSeconds || 10 };
+        const approvalUrl = new URL(started.verificationUriComplete);
+        if (approvalUrl.origin !== new URL(config.baseUrl).origin) throw new Error("Login approval URL does not match the configured LaunchChair origin.");
+        pending = { deviceCode: started.deviceCode, userCode: started.userCode, approvalUrl: approvalUrl.toString(), expiresAt: Date.now() + Number(started.expiresIn || 600) * 1000, nextPollAt: 0 };
+        saveConfig({ pendingMcpLogin: pending });
+      }
+      return { status: "approval_required", approvalUrl: pending.approvalUrl, userCode: pending.userCode, expiresAt: new Date(pending.expiresAt).toISOString(), nextTool: "launchchair_login_status", message: "Open this LaunchChair URL, sign in if needed, and approve this MCP. The workspace owner authorizes token creation." };
+    }
+    if (name === "launchchair_login_status") return loginStatus();
+    if (name === "launchchair_logout") {
+      if (args.revoke === true && currentToken()) {
+        const tokens = await api("/api/agent/v1/tokens");
+        await api(`/api/agent/v1/tokens/${encodeURIComponent(tokens.currentTokenId)}/revoke`, { method: "POST", body: {} });
+      }
+      disconnect();
+      return { status: "logged_out", revoked: args.revoke === true };
+    }
+    if (name === "launchchair_list_tokens") return api("/api/agent/v1/tokens");
+    if (name === "launchchair_create_token") {
+      const { activate: useToken, ...body } = args;
+      const created = await api("/api/agent/v1/tokens", { method: "POST", body });
+      if (!created.token || !created.tokenRecord?.id) throw new Error("Token creation returned incomplete credentials.");
+      const credentialPath = path.join(configDir, "tokens", `${randomUUID()}.json`);
+      mkdirSync(path.dirname(credentialPath), { recursive: true, mode: 0o700 });
+      writeFileSync(credentialPath, JSON.stringify({ agentToken: created.token, baseUrl: config.baseUrl, tokenRecord: created.tokenRecord }) + "\n", { mode: 0o600, flag: "wx" });
+      if (useToken === true) activate(created.token);
+      return { tokenRecord: created.tokenRecord, credentialPath, activated: useToken === true, message: "Token secret saved privately; do not print the credential file in chat." };
+    }
+    if (name === "launchchair_revoke_token") {
+      const result = await api(`/api/agent/v1/tokens/${encodeURIComponent(args.tokenId)}/revoke`, { method: "POST", body: {} });
+      if (result.currentTokenRevoked) disconnect();
+      return result;
+    }
+    if (name === "launchchair_get_run" || name === "launchchair_cancel_run") return api(`/api/agent/v1/runs/${encodeURIComponent(args.runId)}`, name.endsWith("cancel_run") ? { method: "PATCH", body: {} } : {});
+    if (name === "launchchair_next_step") {
+      const projectId = await resolveProjectId(args);
+      const { projectId: _id, projectName: _name, ...body } = args;
+      if (projectSteps.has(projectId)) return { status: "waiting_for_run", projectId, message: "A next_step request is already in progress for this project. Wait for its result." };
+      projectSteps.add(projectId);
+      try {
+      const step = await api(`/api/agent/v1/projects/${encodeURIComponent(projectId)}/loop/continue`, { method: "POST", body });
+      if (step.status === "needs_human_input" && step.current) return { ...step, hostAction: { tool: step.current.cardId ? "launchchair_get_build_cards" : "launchchair_get_bucket", arguments: { projectId, phaseKey: step.current.phaseKey, bucketKey: step.current.bucketKey }, instructions: "Inspect the checkpoint and act with existing user authorization and connected tools. Save verified form/QA results or select a choice consistent with the supplied idea. Ask the user only for information or authorization that is actually missing." } };
+      if (!["queued_run", "waiting_for_run"].includes(step.status) || !step.run?.id) return step;
+      const claimed = await api("/api/agent/v1/runs/next", { method: "POST", body: { projectId, runId: step.run.id, clientName: config.clientName, clientType: config.clientType, clientVersion: config.clientVersion } });
+      if (!claimed.run) return { ...step, run: { id: step.run.id }, status: "waiting_for_run", message: "This run is already claimed. Poll get_run; do not execute it again." };
+      return { ...step, status: "run_ready", run: claimed.run, execution: "host", nextTool: "launchchair_complete_run", instructions: MCP_WORKFLOW_INSTRUCTIONS };
+      } finally { projectSteps.delete(projectId); }
+    }
+    if (name === "launchchair_bind_repository") {
+      const projectId = await resolveProjectId(args);
+      const { workspace } = await api(`/api/agent/v1/projects/${encodeURIComponent(projectId)}/runner-workspace`);
+      const repositoryUrl = workspace?.repository?.repoUrl;
+      if (!repositoryUrl) throw new Error("Save the project repository URL in LaunchChair before binding a clone.");
+      const bound = bindProjectWorkspace({ configPath, projectId, cwd: args.cwd, repositoryUrl });
+      return { projectId, binding: bound };
+    }
+    if (name === "launchchair_research_opportunities") return { audience: args.audience, maxCandidates: args.maxCandidates || 5, validationGate: args.validationGate ?? null, ideaIntent: "explore", steps: ["Research the audience's complaints, current workflows, substitutes, willingness to pay and named competitors using the host's search tools. Cite real sources and distinguish hypotheses from evidence.", "Create separate Product candidates with ideaSnapshot, ideaIntent=explore and a stable idempotencyKey. Include validationGate only when the user requested a score threshold.", "For each candidate call next_step with stopPhaseKey=market_validation, execute the prompt, complete_run and repeat. Inspect errors and perform requested remediation.", "Compare using compare_projects. Build only a qualifying candidate; if none qualifies, continue bounded research or report the unmet thresholds honestly.", "Use host GitHub/Vercel/Supabase plugins after the gate passes, record verified setup with update_bucket, bind_repository, then next_step through launch_sales."], instructions: MCP_WORKFLOW_INSTRUCTIONS };
+    if (name === "launchchair_compare_projects") {
+      if (!Array.isArray(args.projectIds) || !args.projectIds.length || args.projectIds.length > 20) throw new Error("Provide 1–20 projectIds.");
+      const thresholds = args.validationGate && typeof args.validationGate === "object" ? { minPain: 85, minOpportunity: 85, maxSaturation: 30, ...args.validationGate } : { minPain: 85, minOpportunity: 85, maxSaturation: 30 };
+      if (Object.values(thresholds).some((value) => typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 100)) throw new Error("Validation thresholds must be numbers between 0 and 100.");
+      const candidates = [];
+      for (const projectId of [...new Set(args.projectIds)]) {
+        const payload = await api(`/api/agent/v1/projects/${encodeURIComponent(projectId)}/scorecards`);
+        const validation = payload.validationScorecards || payload.scorecards;
+        const cards = Array.isArray(validation) ? validation : validation?.scorecards || [];
+        const score = (id) => cards.find((entry) => entry.id === id)?.score;
+        const pain = score("icp_pain"), opportunity = score("wedge_opportunity"), saturation = score("market_saturation");
+        const qualifies = [pain, opportunity, saturation].every((value) => typeof value === "number") && pain >= thresholds.minPain && opportunity >= thresholds.minOpportunity && saturation <= thresholds.maxSaturation;
+        candidates.push({ projectId, qualifies, pain, opportunity, saturation, validationScorecards: payload });
+      }
+      return { thresholds, candidates, qualifyingProjectIds: candidates.filter((candidate) => candidate.qualifies).map((candidate) => candidate.projectId), message: "These are calculated LaunchChair validation scores, not a guarantee of market success. Preserve supplied ideas; only explore alternatives when requested." };
+    }
+    const definition = definitions.find(([short]) => name === `launchchair_${short}`);
+    if (!definition) return undefined;
+    const [, , , , method, suffix] = definition;
+    const projectId = await resolveProjectId(args);
+    let endpoint = `/api/agent/v1/projects/${encodeURIComponent(projectId)}${suffix.replace(/:(\w+)/g, (_, key) => {
+      if (!args[key]) throw new Error(`${key} is required.`);
+      return encodeURIComponent(args[key]);
+    })}`;
+    if (name === "launchchair_get_bucket_prompt") {
+      const query = new URLSearchParams();
+      if (args.variant) query.set("variant", args.variant);
+      if (args.campaignId) query.set("campaignId", args.campaignId);
+      if (query.size) endpoint += `?${query}`;
+    }
+    const body = args.payload || Object.fromEntries(Object.entries(args).filter(([key]) => !["projectId", "projectName", ...(name === "launchchair_queue_run" ? [] : ["phaseKey", "bucketKey", "cardId"])].includes(key)));
+    return api(endpoint, method === "GET" ? {} : { method, body });
+  }
+  return { currentToken, dispatch };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launchchair/agent",
-  "version": "0.4.12",
+  "version": "0.5.0",
   "mcpName": "io.launchchair/agent",
   "description": "LaunchChair Agent CLI, MCP bridge, local bridge, and runners for Codex, Claude Code, ChatGPT, Claude, and Hermes workflows.",
   "type": "module",
@@ -15,6 +15,7 @@
     "launchchair-cli.mjs",
     "local-bridge.mjs",
     "mcp-bridge-server.mjs",
+    "mcp-capabilities.mjs",
     "project-workspace.mjs",
     "runner-command.mjs",
     "codex-runner.mjs",

package/project-workspace.mjs

@@ -91,7 +91,10 @@ export function readGitOrigin(repoPath) {
   const gitDir = gitDirectory(repoPath);
   if (!gitDir) return "";
   try {
-    const raw = readFileSync(path.join(gitDir, "config"), "utf8");
+    // Linked worktrees keep remote configuration in their common Git directory.
+    const commonPointer = path.join(gitDir, "commondir");
+    const commonDir = existsSync(commonPointer) ? path.resolve(gitDir, readFileSync(commonPointer, "utf8").trim()) : gitDir;
+    const raw = readFileSync(path.join(commonDir, "config"), "utf8");
     const remoteBlock = raw.match(/\[remote\s+"origin"\]([\s\S]*?)(?=\n\[|$)/i)?.[1] ?? "";
     return remoteBlock.match(/^\s*url\s*=\s*(.+)$/im)?.[1]?.trim() ?? "";
   } catch {

package/server.json

@@ -3,13 +3,13 @@
   "name": "io.launchchair/agent",
   "title": "LaunchChair",
   "description": "Plan, validate, and build products and features with LaunchChair.",
-  "version": "0.4.12",
+  "version": "0.5.0",
   "websiteUrl": "https://www.launchchair.io/docs/mcp",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@launchchair/agent",
-      "version": "0.4.12",
+      "version": "0.5.0",
       "runtimeHint": "npx",
       "runtimeArguments": [
         {
@@ -29,8 +29,8 @@
       "environmentVariables": [
         {
           "name": "LAUNCHCHAIR_AGENT_TOKEN",
-          "description": "LaunchChair Agent API token from Settings > API Access.",
-          "isRequired": true,
+          "description": "Optional pre-existing token. Without it, call launchchair_login for browser approval and private token storage.",
+          "isRequired": false,
           "isSecret": true,
           "format": "string"
         }