@launchchair/agent 0.4.12 → 0.5.1

package/AGENTS.md

@@ -35,6 +35,9 @@ 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/mcp-widgets.mjs" -o "$HOME/launchchair-agent/mcp-widgets.mjs"
+curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/mcp-widget.html" -o "$HOME/launchchair-agent/mcp-widget.html"
 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 +78,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,14 +125,15 @@ 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.
+9. In hosts that support MCP Apps, present `launchchair_show_choices` at a choice step and after a selection, `launchchair_show_phase_synthesis` after phase completion, and `launchchair_show_validation_scores` for validation results. Their Next action controls return work to the host agent. If UI is unsupported, summarize the structured result and show the returned URLs.
 
 ## Consent Behavior
 
@@ -218,7 +222,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 +237,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 +265,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,37 @@ 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.1 adds tabbed MCP Apps widgets for saved choices, rich phase synthesis, and Product/Feature validation scorecards to 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.
+
+## Agent response widgets
+
+The bridge supports LaunchChair AUX through MCP Apps. Three read-only tools return tabbed widgets using the app's Chakra theme, shared choice cards, and existing strategic scorecards:
+
+- `launchchair_show_choices` (`projectId`, `phaseKey`, `bucketKey`): generated options and the saved choice.
+- `launchchair_show_phase_synthesis` (`projectId`, `phaseKey`): the app's phase-specific synthesis cards, native tabs and charts, with verified completion state.
+- `launchchair_show_validation_scores` (`projectId`): validation scorecards, evidence inputs, and separate direction scores for Product and Feature projects.
+
+Every widget includes **Next action** controls. Saving a choice calls the existing `launchchair_select_choice` tool, then rereads the saved selection. Continue/review actions send a message to the host agent; the host executes queued prompts with its tools. The iframe never receives a token or calls the API directly. Existing scopes, entitlements, idea policies, validation gates, and downstream resets still apply.
+
+The content pane scrolls at 560px on desktop and 440px on smaller screens using the app's scrollbar styles. The next-action footer stays outside that pane. Selected choices reuse the same choice cards, and validation thresholds live inside the scorecard footer. Synthesis reads the sanitized spec through the existing export permission; competitor editing and workspace notes remain in the authenticated app.
+
+Rendering uses `_meta.ui.resourceUri`, `text/html;profile=mcp-app` resources, and the MCP Apps JSON-RPC host bridge. Compatible ChatGPT hosts can also use the feature-detected `window.openai` aliases. Text-only clients receive the full structured result and URLs. Static templates can be discovered while logged out; project reads still require authentication.
+
+From the repository root, run `npm run agent:widgets:build` after changing widget components or the theme. This rebuilds the self-contained HTML in both bridge distributions. `npm run agent:widgets:preview -- /absolute/path/examples.html` builds interactive local examples with labeled sample data. Nothing is published by these commands.
+
+The choice widget requires the bucket API's additive `choice` fields. Synthesis requests the existing export endpoint with `?format=json`; default Markdown downloads are unchanged. Test against a matching local API before releasing. Release the matching API changes before publishing the bridge package so installed clients can read the new choice and synthesis payloads.
 
 ## Login
 
@@ -49,7 +62,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 +131,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 +194,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 +243,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.1";
 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.1";
 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 ?? ""),