Everything you need to know

Set up HubLaunch in this repository.

1. Install the HubLaunch CLI by running `curl -fsSL https://hublaunch.site/install.sh | sh`. (If I prefer Node, `npm install -g hub-launch` -- or `pnpm add -g hub-launch` for a pnpm project -- works instead.)
2. `hula init` cannot be run by you: it's an interactive wizard (asks which LLM provider I use, then asks for a credential) with no flag or non-interactive mode to answer those prompts through a tool call. Tell me to run `hula init` myself in my own terminal, then wait for me to say it's done -- don't try to script, pipe, or guess answers into it. It also logs me in at the end (opens my browser for GitHub + HubLaunch and, if needed, asks me to install HubLaunch's GitHub App on this repo), so there is no separate login step for you to run. If I tell you that login part didn't complete, run `hula login` yourself: it prints a URL and a one-time code -- show them to me, then just wait while it polls.
3. Once I confirm `hula init` finished, run `hula --version` to confirm the install worked, then tell me setup is done and that I can say "/hula-help" any time for a guided tour of what to do next.
4. Mention, once, that HubLaunch's free tier covers planning and tracking with no time limit, and that launching a plan into a cloud sandbox needs Pro -- point me to https://hublaunch.site/pricing if I want to see plans. This is purely informational: don't ask me to decide now, and don't block on it -- I can keep using the free tier for as long as I want.

Don't run `hula launch`, `hula create`, or touch any plan files yet -- this is just install + init.

Set up completion notifications for HubLaunch in this repo.

1. Ask me which channel I want to use: Slack, Discord, Telegram, or something else that can receive a webhook (n8n, Pipedream, ntfy, a server you run).
2. Slack: tell me to create an Incoming Webhook at https://api.slack.com/messaging/webhooks for the channel I want, and have me paste you the resulting URL (it starts with https://hooks.slack.com/services/). Don't try to create it yourself -- that's a few clicks in Slack's own UI.
3. Discord or Telegram: HubLaunch posts generic JSON, which neither platform accepts directly, so these need a small relay in between. Point me at this project's notifications guide for a working Telegram example (a small Cloudflare Worker), and tell me the same relay pattern adapts to Discord's webhook format.
4. Once I've given you a URL, open `.hublaunch/hublaunch.config.js` in this repo and set:
   `updateNotificationUrl: "<the URL I gave you>"`
   and, only if I asked for an @-mention on Slack, `updateNotificationNameTag: "<@my-slack-id>"`.
5. Show me the diff before saving, then confirm it's set. From the next `hula launch` onward, this URL gets a POST when the run starts, when the GitHub issue is created, and when the PR is ready or the run fails.

Set up a local "watch and review" helper for HubLaunch runs in this repo.

1. Ask me what command verifies this project (e.g. `npm test`, `pnpm run check`, `make verify`).
2. Create `.hublaunch/watch.sh` with the script below, replacing the VERIFY_CMD line with my answer:

#!/usr/bin/env bash
# .hublaunch/watch.sh -- poll a HubLaunch run, then show its summary, diff,
# and run this project's own verification command.
# Usage: .hublaunch/watch.sh <trackingName>
set -euo pipefail

TRACKING_NAME="${1:?usage: .hublaunch/watch.sh <trackingName>}"
POLL_INTERVAL="${POLL_INTERVAL:-15}"   # seconds between polls
VERIFY_CMD="npm test"                  # replace with this project's check command

echo "Watching '$TRACKING_NAME' (polling every ${POLL_INTERVAL}s)..."

while true; do
  if ! RAW_OUTPUT=$(hula launch --show "$TRACKING_NAME" 2>&1); then
    echo "Could not reach HubLaunch -- retrying won't help until this clears:"
    echo "$RAW_OUTPUT"
    exit 1
  fi
  STATUS_LINE=$(echo "$RAW_OUTPUT" | grep "Status:" || true)

  if echo "$STATUS_LINE" | grep -qi "completed"; then
    echo "Run completed - PR is ready."
    break
  elif echo "$STATUS_LINE" | grep -qi "failed"; then
    echo "Run failed. Recent logs:"
    hula info "$TRACKING_NAME" --logs
    exit 1
  elif echo "$STATUS_LINE" | grep -qi "cancelled"; then
    echo "Run was cancelled."
    exit 1
  fi

  echo "  ...${STATUS_LINE:-queued}"
  sleep "$POLL_INTERVAL"
done

echo ""
echo "-- Summary --"
hula info "$TRACKING_NAME" --initial --raw

echo ""
echo "-- Diff --"
hula info "$TRACKING_NAME" --diff

echo ""
echo "-- Verify --"
eval "$VERIFY_CMD"

3. Run `chmod +x .hublaunch/watch.sh`.
4. Tell me to run `.hublaunch/watch.sh <trackingName>` right after `hula launch <trackingName> <planPath>`, using the same trackingName both times. It polls until the run finishes, then prints the PR summary, opens the diff, and runs my verify command -- showing me exactly what changed and whether it's safe to approve, without me checking back manually.

Don't run the script yourself unless I ask -- just create it and explain how I'll use it.

Set up an Error Watcher for this project, so a runtime crash in production becomes a diagnosed fix automatically -- a pull request by default, or set `--outcome-type plan` / `--outcome-type feedback` instead if you'd rather get a written plan or diagnosis with no code changes.

1. If HubLaunch isn't installed in this repo yet, do the Setup steps above first (`curl -fsSL https://hublaunch.site/install.sh | sh` -- or, for Node, `npm install -g hub-launch` -- then `hula login`, `hula init`).
2. Run `hula error-watcher --create`. The Anthropic API key already lives in `.hublaunch/hublaunch.config.js` (`provider.apiKey`), so you don't need to ask me for one -- it resolves automatically. Add `--environments <comma-separated list>` only if this project's production environment isn't literally named `production` (that's the default). This prints a `.env` block and a signed-request snippet, but the ingest key/secret inside that block are placeholders -- the CLI has no route to mint a real one.
3. Tell me to open https://hublaunch.site/dashboard/projects, click the gear icon on this project's card, then scroll to "Error reporting API keys" and create a key there myself -- the key and its signing secret are shown exactly once, so tell me to copy them (the page has a single "Copy .env block" button that copies all three values together) and paste them back to you right away.
4. Take the `.env` block from step 2's output, substitute in the real key and secret I gave you, and add it to this app's production environment (e.g. `.env.production`, or your hosting provider's environment variable settings).
5. Wire the signed-request snippet from step 2's output into this app's global error handler (or wherever it should report a crash), replacing the identity fields (`key`, `errorName`, `errorCode`) with real values for the error you want tracked -- send at least `key`, since sending none of the three means every error on this project shares a single fix run per day.

Don't run `hula error-watcher --delete` or touch a watcher that already exists on this project -- only create a new one if step 2 reports none exists yet.