@launchchair/agent 0.4.0

package/AGENTS.md

@@ -0,0 +1,248 @@
+# LaunchChair Agent Bootstrap
+
+This file is for fresh agent chats that need to use the LaunchChair Agent API or MCP bridge without wasting time searching an empty repo.
+
+## Core Rule
+
+Use LaunchChair first for product, research, validation, positioning, pricing, MVP blueprint, and phase-loop work. Do not inspect the local repo first unless the user is in Stack Setup, Build MVP, Design and Landing Page implementation, or another code-changing phase.
+
+Fresh LaunchChair projects often do not have a local repo yet. Before Stack Setup, the configured runner folder may be empty on purpose.
+
+## Public Docs To Read
+
+- Agent API docs: https://www.launchchair.io/docs/agent-api
+- MCP setup docs: https://www.launchchair.io/docs/mcp
+- Optional CLI docs: https://www.launchchair.io/docs/cli
+- Public machine-readable catalog: https://www.launchchair.io/api/agent/v1/docs
+- Bridge file catalog: https://www.launchchair.io/api/agent/v1/bridge
+
+## Security Rules
+
+- Never print a LaunchChair token.
+- Never paste a LaunchChair token into public docs, issue comments, screenshots, or chat summaries.
+- Real tokens come from LaunchChair Settings -> API Access or from an approved `launchchair login` browser flow.
+- Public docs and artifacts contain placeholders only.
+- If you inspect env files, confirm whether token variables exist without showing their values.
+- If the user asks you to create or continue a LaunchChair project and the configured token permits it, do not ask for extra confirmation before using LaunchChair MCP/API tools. The token scope is the authorization boundary.
+- Ask for confirmation only for external account authorization, production SQL execution, destructive local file actions, or shell commands that the client sandbox requires the user to approve.
+
+## Bridge And Runner Files
+
+Download these into a stable local folder such as `~/launchchair-agent` or `~/.hermes/launchchair-mcp`:
+
+```bash
+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/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"
+curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/claude-code-runner.mjs" -o "$HOME/launchchair-agent/claude-code-runner.mjs"
+curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/chatgpt-runner.mjs" -o "$HOME/launchchair-agent/chatgpt-runner.mjs"
+curl -fsSL "https://www.launchchair.io/api/agent/v1/bridge/claude-runner.mjs" -o "$HOME/launchchair-agent/claude-runner.mjs"
+curl -fsSL "https://www.launchchair.io/agent-artifacts/AGENTS.md" -o "$HOME/launchchair-agent/AGENTS.md"
+chmod +x "$HOME/launchchair-agent"/*.mjs
+LAUNCHCHAIR_AGENT_WORKDIR="${LC_AGENT_CODEX_CWD:-${LC_AGENT_CLAUDE_CODE_CWD:-$PWD}}"
+if [ -d "$LAUNCHCHAIR_AGENT_WORKDIR" ] && [ ! -f "$LAUNCHCHAIR_AGENT_WORKDIR/AGENTS.md" ]; then
+  printf '%s\n' \
+    '# LaunchChair Agent Bootstrap Pointer' \
+    '' \
+    'Before searching this repo, read ~/launchchair-agent/AGENTS.md.' \
+    'Use LaunchChair MCP/API first for product phases, project discovery, project creation, and phase loops.' \
+    'Do not ask for extra confirmation before using LaunchChair MCP/API when the user already requested the action and the token permits it.' \
+    'Only inspect this repo for Stack Setup, Build MVP, Design/Landing Page, SEO implementation, smoke testing, security review, or code remediation.' \
+    > "$LAUNCHCHAIR_AGENT_WORKDIR/AGENTS.md"
+fi
+```
+
+The final block creates a tiny project-local `AGENTS.md` pointer only when the target folder does not already have one. It helps fresh Codex chats auto-load the LaunchChair instructions without overwriting a real project instruction file.
+
+## Optional CLI
+
+MCP-only setup is still supported. Use `mcp-bridge-server.mjs` when the desktop agent exposes LaunchChair MCP tools. Use `launchchair-cli.mjs` when you need quick diagnostics, project discovery, retry-safe project creation, MCP config output, or a simple way to start the local bridge.
+
+```bash
+node "$HOME/launchchair-agent/launchchair-cli.mjs" doctor
+node "$HOME/launchchair-agent/launchchair-cli.mjs" login
+node "$HOME/launchchair-agent/launchchair-cli.mjs" projects --query LeafLore
+node "$HOME/launchchair-agent/launchchair-cli.mjs" create --name SignalLift --one-liner "Distribution workspace for technical founders" --project-type b2b --idempotency-key signallift-v1
+node "$HOME/launchchair-agent/launchchair-cli.mjs" run-once
+node "$HOME/launchchair-agent/launchchair-cli.mjs" bridge
+node "$HOME/launchchair-agent/launchchair-cli.mjs" mcp-config codex
+```
+
+## Required Environment Variables
+
+```bash
+LAUNCHCHAIR_BASE_URL="https://www.launchchair.io"
+LAUNCHCHAIR_AGENT_TOKEN="<full lc_at token from LaunchChair Settings API Access>"
+LAUNCHCHAIR_PROJECT_ID="optional project UUID; omit or leave blank if creating or discovering a project"
+```
+
+For Codex Desktop local runs:
+
+```bash
+LC_AGENT_ROUTER_GPT_TARGET="codex"
+LC_AGENT_ROUTER_CODEX_TARGET="codex"
+LC_AGENT_CODEX_CWD="/absolute/path/to/the-folder-codex-should-build-into"
+```
+
+For Claude Desktop plus Claude Code local runs:
+
+```bash
+LC_AGENT_ROUTER_GPT_TARGET="claude_code"
+LC_AGENT_ROUTER_CODEX_TARGET="claude_code"
+LC_AGENT_CLAUDE_CODE_CWD="/absolute/path/to/the-folder-claude-code-should-build-into"
+```
+
+The build folder can be an empty scratch folder until Stack Setup creates or records the GitHub repository. After Stack Setup, the user should clone the generated repo locally or update the runner CWD to the cloned repo path.
+
+## MCP Server Config Example
+
+```toml
+[mcp_servers.launchchair]
+command = "node"
+args = ["/Users/you/launchchair-agent/mcp-bridge-server.mjs"]
+
+[mcp_servers.launchchair.env]
+LAUNCHCHAIR_BASE_URL = "https://www.launchchair.io"
+LAUNCHCHAIR_AGENT_TOKEN = "<full lc_at token from Settings API Access>"
+LAUNCHCHAIR_PROJECT_ID = ""
+LC_AGENT_ROUTER_GPT_TARGET = "codex"
+LC_AGENT_ROUTER_CODEX_TARGET = "codex"
+LC_AGENT_CODEX_CWD = "/absolute/path/to/the-folder-codex-should-build-into"
+```
+
+## 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.
+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`.
+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.
+
+## Consent Behavior
+
+Do not ask the user for repeated permission to perform normal LaunchChair project-loop work when the user already requested it and the token allows it.
+
+Safe LaunchChair MCP/API actions that should not need another user confirmation:
+
+- creating a LaunchChair project with `launchchair_create_project`
+- listing accessible LaunchChair projects with `launchchair_list_projects`
+- continuing a project loop with `launchchair_continue_project`
+- selecting a generated wedge, pricing, or feature direction with `launchchair_select_choice`
+- running/rerunning Product Ideation, Market Validation, Positioning, Pricing, and MVP Blueprint buckets
+- returning phase synthesis links and selected choices
+
+Stop and ask only when:
+
+- the local client sandbox asks the user to approve a shell command
+- the user must authorize GitHub, Vercel, Supabase, Stripe, or another external account
+- production SQL must be executed
+- Product-track manual QA requires a human when LaunchChair explicitly returns that checkpoint; Feature-track QA should be executed by the agent with matching evidence whenever the local runtime is available
+- a destructive local filesystem action is required
+- the token is missing a required scope
+
+If Codex asks for permission to run the local bridge fallback command, tell the user they can choose "Yes, and don't ask again for commands that start with ..." for the LaunchChair bridge command prefix. Prefer exposed MCP tools when available because MCP tool calls avoid shell-command permission prompts.
+
+## When To Avoid Repo Inspection
+
+Do not start with `ls`, `rg`, dependency inspection, or nearby repo searches when the user asks for:
+
+- product ideation
+- market validation
+- ICP research
+- wedge selection
+- positioning and pricing
+- MVP blueprint
+- LaunchChair project creation
+- LaunchChair phase loops
+- score-based reruns such as ICP Pain Score, Market Saturation Score, or Wedge Opportunity Score
+
+Those are LaunchChair project-state tasks, not local repo tasks.
+
+## When Repo Inspection Is Correct
+
+Inspect the repo when the current LaunchChair work is:
+
+- Stack Setup local readiness
+- Build MVP cards
+- Design and Landing Page implementation
+- SEO, GEO, AEO implementation against an existing app
+- smoke testing, security review, or code remediation
+
+For Build MVP work, read the repo `AGENTS.md` first if it exists, then inspect the files named in the LaunchChair build prompt.
+
+## Human Checkpoints
+
+Stop and give the user a direct LaunchChair link when LaunchChair needs:
+
+- GitHub authorization or repo selection
+- Vercel account, team, project, or domain selection
+- Supabase project selection or SQL execution
+- Stripe account authorization
+- Product-track manual QA, or Feature QA that is genuinely blocked by unavailable credentials, external authorization, or an inaccessible runtime
+- a human product choice that the token cannot save
+
+Do not claim that SQL migrations, production deploys, billing setup, or QA are complete unless you have verified evidence. For Feature projects, run the available QA yourself and return matching `executionEvidence.agentQaChecks` instead of handing runnable checks back to the user.
+
+## Progress Reporting
+
+Keep chat updates short. Report:
+
+- the LaunchChair project name and phase
+- the bucket or card being worked
+- choices selected, especially wedge, pricing, and feature direction
+- phase synthesis links returned by LaunchChair
+- exact user checkpoints with links to the relevant LaunchChair page or build-card tab
+
+Avoid long explanations of local file searching when LaunchChair MCP tools are available.
+
+## Common Commands
+
+Run a full project loop:
+
+```text
+Call launchchair_continue_project with projectId, maxSteps, and optional stopPhaseKey.
+```
+
+Create a project from a new idea:
+
+```text
+Call launchchair_create_project with projectName, oneLiner, projectType, and ideaSnapshot.
+```
+
+Find a project by name:
+
+```text
+Call launchchair_list_projects with query set to the user-provided project name.
+```
+
+Run one queued UI job:
+
+```text
+Call launchchair_run_once.
+```
+
+Run one queued UI job from CLI:
+
+```bash
+node "$HOME/launchchair-agent/launchchair-cli.mjs" run-once
+```
+
+Select a generated wedge:
+
+```text
+Call launchchair_select_choice with domain="wedge" and optionTitle or optionId.
+```
+
+## Do Not Do This
+
+- Do not brute-force project state by writing arbitrary JSON Patch to `projects.spec_json`.
+- Do not use generic SPEC_UPDATE for user-choice buckets.
+- Do not invent missing Supabase, Vercel, GitHub, or Stripe access.
+- 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.

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) LaunchChair.
+
+All rights reserved.
+
+This package is provided for use with LaunchChair services. You may install,
+execute, and configure this package to connect authorized local agent clients to
+LaunchChair. No permission is granted to copy, modify, sublicense, sell, or
+redistribute this package except as expressly permitted by LaunchChair.

package/README.md

@@ -0,0 +1,188 @@
+# LaunchChair Agent
+
+LaunchChair Agent packages the LaunchChair CLI, MCP bridge, local bridge, and runner scripts used by Codex, Claude Code, ChatGPT, Claude, and Hermes workflows.
+
+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:
+
+```bash
+npm pack
+npm install -g ./launchchair-agent-*.tgz
+launchchair help
+launchchair doctor
+```
+
+After publishing:
+
+```bash
+npm install -g @launchchair/agent
+launchchair help
+launchchair doctor
+```
+
+## Login
+
+Approve the CLI once in your browser. LaunchChair creates a scoped Agent API token after approval and the CLI stores it locally:
+
+```bash
+launchchair login
+launchchair doctor
+launchchair whoami
+```
+
+Manual fallback when you already have a token from LaunchChair Settings -> API Access:
+
+```bash
+launchchair login --token "<full lc_at token from LaunchChair Settings API Access>"
+```
+
+The CLI stores local config at:
+
+```text
+~/.launchchair/config.json
+```
+
+Tokens are masked in CLI output. Do not paste real tokens into public docs, screenshots, issue comments, or chat summaries.
+
+## Guided Setup
+
+Use `setup` as the easiest path. It saves the build folder, writes a small `AGENTS.md` pointer into that folder, starts browser login when no token is saved yet, prints the MCP config for your desktop agent, and tells you exactly what to do next.
+
+Codex Desktop:
+
+```bash
+launchchair setup codex --cwd /absolute/path/to/repo-or-empty-folder
+```
+
+Claude Desktop + Claude Code:
+
+```bash
+launchchair setup claude --cwd /absolute/path/to/repo-or-empty-folder
+```
+
+Terminal / CLI agents:
+
+```bash
+launchchair setup terminal --cwd /absolute/path/to/repo-or-empty-folder
+```
+
+If you do not want browser login during setup, add `--skip-login`. You can also save an existing token during setup:
+
+```bash
+launchchair setup codex --cwd . --skip-login
+launchchair setup codex --cwd . --token "<full lc_at token from LaunchChair Settings API Access>"
+```
+
+For a fresh project before a repo exists, point `--cwd` at an empty folder. LaunchChair can run ideation, validation, positioning, pricing, and MVP blueprint before code exists; Stack Setup and Build MVP can later use that folder as the build target.
+
+Use `setup terminal` when the agent runs inside a normal shell instead of Codex Desktop or Claude Desktop MCP. It writes the same project-local `AGENTS.md` pointer, saves the build folder, and prints the CLI commands the agent should use: `launchchair projects`, `launchchair create`, `launchchair continue`, `launchchair run-once`, and `launchchair bridge`.
+
+## Common Commands
+
+```bash
+launchchair setup codex --cwd /absolute/path/to/repo-or-empty-folder
+launchchair setup claude --cwd /absolute/path/to/repo-or-empty-folder
+launchchair setup terminal --cwd /absolute/path/to/repo-or-empty-folder
+launchchair projects
+launchchair projects --query LeafLore
+launchchair create --name "SignalLift" --one-liner "Distribution workspace for technical founders" --project-type b2b --save-project
+launchchair continue --stop-phase-key market_validation
+launchchair continue --completion-target "rerun Product Ideation until ICP Pain Score is above 85"
+launchchair run-once
+launchchair bridge
+launchchair mcp-config codex
+launchchair mcp-config claude
+launchchair install-agent-md --cwd /absolute/path/to/repo-or-empty-folder
+```
+
+Feature beta projects can be created and planned from the CLI when the token owner has access:
+
+```bash
+launchchair create \
+  --name "Retention Engine" \
+  --project-kind feature \
+  --feature-description "Add account-level lifecycle nudges to an existing SaaS dashboard" \
+  --problem "Activated users forget the next valuable action after onboarding" \
+  --product-description "Existing B2B SaaS dashboard with auth, billing, and workspace teams" \
+  --plan-to-build-board \
+  --save-project
+
+# Optional: continue from feature planning into Build MVP
+launchchair create \
+  --name "Retention Engine" \
+  --project-kind feature \
+  --feature-description "Add account-level lifecycle nudges to an existing SaaS dashboard" \
+  --problem "Activated users forget the next valuable action after onboarding" \
+  --full-loop \
+  --max-steps 12 \
+  --build-max-steps 25
+```
+
+## MCP Config
+
+Print a Codex MCP config example:
+
+```bash
+launchchair mcp-config codex
+```
+
+Print a Claude Desktop MCP config example:
+
+```bash
+launchchair mcp-config claude
+```
+
+The printed config intentionally uses a token placeholder. Paste your real `lc_at_` token into your MCP client config when the desktop client launches MCP directly, or use `launchchair login` for CLI-started bridge sessions.
+
+Desktop MCP clients do not automatically inherit the token saved by `launchchair login` unless they launch through a CLI-managed bridge process. For direct MCP config, put the token in that client config's `env` block.
+
+## Local Bridge
+
+Use the local bridge when the LaunchChair web app's `Run with agent` button should queue work and your local agent should pick it up:
+
+```bash
+launchchair bridge
+```
+
+For a one-shot test:
+
+```bash
+launchchair run-once
+```
+
+## Runner Targets
+
+Codex:
+
+```bash
+launchchair config set codex-cwd /absolute/path/to/repo-or-empty-folder
+launchchair bridge
+```
+
+Claude Code:
+
+```bash
+launchchair config set claude-code-cwd /absolute/path/to/repo-or-empty-folder
+LC_AGENT_ROUTER_GPT_TARGET=claude_code LC_AGENT_ROUTER_CODEX_TARGET=claude_code launchchair bridge
+```
+
+ChatGPT and Claude API runner fallbacks require provider API keys:
+
+```bash
+OPENAI_API_KEY=... launchchair bridge
+ANTHROPIC_API_KEY=... launchchair bridge
+```
+
+## Fresh Agent Chats
+
+This package includes `AGENTS.md`. Fresh Codex, Claude, and Hermes chats should read that file before searching an empty repo. Product ideation, market validation, positioning, pricing, MVP blueprint, and project loops are LaunchChair API/MCP tasks. Local repo inspection starts later, usually at Stack Setup or Build MVP.
+
+## Docs
+
+- CLI docs: https://www.launchchair.io/docs/cli
+- 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

package/chatgpt-runner.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+
+function env(name, fallback = "") {
+  const value = process.env[name];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+
+function toInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function toFloat(value, fallback) {
+  const parsed = Number.parseFloat(String(value ?? ""));
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function stripCodeFence(text) {
+  const trimmed = String(text ?? "").trim();
+  if (!trimmed.startsWith("```")) {
+    return trimmed;
+  }
+  const lines = trimmed.split("\n");
+  if (lines.length < 3) {
+    return trimmed;
+  }
+  const first = lines[0].trim();
+  const last = lines[lines.length - 1].trim();
+  if (!first.startsWith("```") || last !== "```") {
+    return trimmed;
+  }
+  return lines.slice(1, -1).join("\n").trim();
+}
+
+function tryJsonParse(candidate) {
+  try {
+    return { ok: true, value: JSON.parse(candidate) };
+  } catch {
+    return { ok: false, value: null };
+  }
+}
+
+function extractFirstJsonValue(text) {
+  const raw = String(text ?? "");
+  const direct = tryJsonParse(raw.trim());
+  if (direct.ok) {
+    return direct.value;
+  }
+
+  const unfenced = stripCodeFence(raw);
+  const fromFence = tryJsonParse(unfenced);
+  if (fromFence.ok) {
+    return fromFence.value;
+  }
+
+  for (let start = 0; start < unfenced.length; start += 1) {
+    const open = unfenced[start];
+    if (open !== "{" && open !== "[") {
+      continue;
+    }
+    const close = open === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+
+    for (let i = start; i < unfenced.length; i += 1) {
+      const char = unfenced[i];
+
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === "\"") {
+          inString = false;
+        }
+        continue;
+      }
+
+      if (char === "\"") {
+        inString = true;
+        continue;
+      }
+      if (char === open) {
+        depth += 1;
+        continue;
+      }
+      if (char === close) {
+        depth -= 1;
+        if (depth === 0) {
+          const candidate = unfenced.slice(start, i + 1).trim();
+          const parsed = tryJsonParse(candidate);
+          if (parsed.ok) {
+            return parsed.value;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    process.stdin.on("end", () => resolve(buffer));
+    process.stdin.on("error", (error) => reject(error));
+  });
+}
+
+function extractCompletionText(payload) {
+  const choices = Array.isArray(payload?.choices) ? payload.choices : [];
+  const choice = choices[0] ?? null;
+  const content = choice?.message?.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const merged = content
+      .map((part) => {
+        if (typeof part?.text === "string") {
+          return part.text;
+        }
+        if (typeof part?.content === "string") {
+          return part.content;
+        }
+        return "";
+      })
+      .join("\n")
+      .trim();
+    if (merged) {
+      return merged;
+    }
+  }
+  if (typeof payload?.output_text === "string") {
+    return payload.output_text;
+  }
+  throw new Error("OpenAI response did not include assistant text.");
+}
+
+async function callOpenAi(input, config) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), config.timeoutMs);
+
+  try {
+    const response = await fetch(`${config.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: config.model,
+        temperature: config.temperature,
+        max_tokens: config.maxTokens,
+        messages: [
+          {
+            role: "system",
+            content:
+              "Return exactly one valid JSON value (object or array) and nothing else. No markdown, no prose.",
+          },
+          {
+            role: "user",
+            content: input,
+          },
+        ],
+      }),
+      signal: controller.signal,
+    });
+
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const detail = String(payload?.error?.message ?? payload?.error ?? response.statusText ?? "Request failed");
+      throw new Error(`OpenAI request failed (${response.status}): ${detail}`);
+    }
+
+    return extractCompletionText(payload);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function main() {
+  const config = {
+    apiKey: env("OPENAI_API_KEY"),
+    baseUrl: env("OPENAI_BASE_URL", "https://api.openai.com/v1").replace(/\/+$/, ""),
+    model: env("LC_AGENT_OPENAI_MODEL", env("OPENAI_MODEL", "gpt-5-mini")),
+    temperature: toFloat(process.env.LC_AGENT_OPENAI_TEMPERATURE, 0),
+    maxTokens: toInt(process.env.LC_AGENT_OPENAI_MAX_TOKENS, 12000),
+    timeoutMs: toInt(process.env.LC_AGENT_OPENAI_TIMEOUT_MS, 180000),
+    maxAttempts: toInt(process.env.LC_AGENT_JSON_MAX_ATTEMPTS, 3),
+  };
+
+  if (!config.apiKey) {
+    throw new Error("Missing OPENAI_API_KEY for chatgpt-runner.");
+  }
+
+  const prompt = String(await readStdin()).trim();
+  if (!prompt) {
+    throw new Error("Runner received an empty prompt.");
+  }
+
+  let lastRaw = "";
+  for (let attempt = 1; attempt <= config.maxAttempts; attempt += 1) {
+    const input =
+      attempt === 1
+        ? prompt
+        : [
+            "Repair this to strict valid JSON only.",
+            "Do not add explanations, markdown, or code fences.",
+            "Return exactly one JSON value.",
+            "",
+            lastRaw,
+          ].join("\n");
+
+    lastRaw = await callOpenAi(input, config);
+    const parsed = extractFirstJsonValue(lastRaw);
+    if (parsed !== null) {
+      process.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
+      return;
+    }
+  }
+
+  throw new Error("Model did not return valid JSON after retry attempts.");
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error ?? "chatgpt-runner failed");
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});