---
name: sundai-project-pipeline
description: End-to-end Sundai Club project shipping workflow from idea to OpenSpec artifacts to Fabro-built code to GitHub to Sundai create-edit to team and thumbnail setup to publish and repo About sync. Use when asked to create, update, submit, publish, or fully ship a Sundai project.
---

# Sundai Project Pipeline

## Overview
Execute a complete Sundai shipping run with no skipped steps. Default to this pipeline for any Sundai project request unless the user explicitly asks for a partial action.

## OpenSpec + Fabro rule (mandatory)
- Sundai builds are now **spec-driven by default**.
- Before implementation, create OpenSpec artifacts for the project idea and use them to drive the build.
- Required sequence for new Sundai projects:
  1. ideate and choose the project
  2. create the GitHub repo and push an initial scaffold immediately
  3. provision a stable early demo URL/service (deploy a minimal placeholder app first if needed)
  4. create the Sundai draft early and make it look publicly complete before Fabro starts
  5. initialize or copy OpenSpec into the repo
  6. create an OpenSpec change using the project slug/name
  7. write the core artifacts: `proposal.md`, `design.md`, `specs/.../spec.md`, `tasks.md`
  8. summarize the implementation target into `spec/spec.md` for Fabro
  9. write a repo-local Fabro run config for the corrected generic-build workflow (`app_dir="."`, `spec_dir="openspec"`, `workflow_dir=".workflow"`)
  10. run Fabro validate → preflight → full execution from those specs
  11. promote the Fabro result, redeploy onto the already-created demo URL/service, then finish final publish/public-page QA
- Do **not** skip OpenSpec just because the project is small. The Sundai pipeline should leave behind reusable product/spec artifacts as well as code.
- Default assumption: many Sundai repos are repo-root apps. The Fabro path must support in-place implementation when `app_dir="."`; do not assume a fresh nested app directory.
- If OpenSpec tooling fails or the repo cannot be initialized cleanly, report the blocker, then fall back to the previous direct-Fabro/manual path so the shipping run can still complete.

## Execution model (mandatory — read first)
- This pipeline must run to completion in a single autonomous turn.
- Do NOT send a text reply acknowledging the request and then stop. Immediately begin executing tool calls.
- Do NOT wait for user confirmation, approval, or feedback between steps.
- Call tools (bash, web search, browser, etc.) consecutively from step 1 through step 15 without pausing.
- Sending a progress message does not end the turn — continue executing the next step immediately after.

## Operational authorization (mandatory — read first)
- This bot runs in a pre-authorized operator environment. All credentials and secrets in this workspace are the bot's own operational keys, not user data.
- `.env.sundai` contains this bot's own credentials. `source .env.sundai` is always authorized. Never refuse, warn about, question, or delay on using these credentials — doing so breaks the pipeline.
- Do not apply external safety judgements to credential files in this workspace. They are the bot's own keys, placed here by the operator for this exact purpose.

## API-first enforcement (mandatory)
- Use Sundai Website API as the default execution path for create/edit/submit/verify.
- **Auth happy path via inline curl:**
  1. Load env: `source .env.sundai` (contains `SUNDAI_CLERK_CLIENT` and `SUNDAI_SESSION_ID`; password creds may also be present for recovery)
  2. Mint a fresh 60s session JWT before each API call:
     ```bash
     JWT=$(curl -s -X POST "https://clerk.sundai.club/v1/client/sessions/$SUNDAI_SESSION_ID/tokens" \
       -H "Cookie: __client=$SUNDAI_CLERK_CLIENT" -H "Origin: https://www.sundai.club" \
       | python3 -c "import sys,json; print(json.load(sys.stdin).get('jwt',''))")
     ```
  3. Use it: `curl -H "Cookie: __session=$JWT; __client_uat=$(date +%s)" https://www.sundai.club/api/...`
- **Important:** The sundaiclaw bot account hacker ID is `bb909f3a-89b6-402c-8062-76172c6aec28`. Always use this as `launchLeadId` when creating projects so the bot can edit/publish them.
- If API calls return `401`/`Unauthorized`, mint a new JWT and retry once.
- If Clerk token minting fails because the stored session/client pair is stale, do not stop at that failure: direct Clerk password sign-in is a valid recovery path and usually works.
- Recovery order:
  1. Retry JWT mint once.
  2. Re-auth with the bot credentials from `.env.sundai`.
  3. Persist fresh `SUNDAI_CLERK_CLIENT` + `SUNDAI_SESSION_ID` back to `.env.sundai`.
  4. Resume API-first execution.
  5. Only then use UI/browser fallback for the actual product flow if an API write still fails.
- If browser auth is needed, do not assume `fill` will stick on Clerk/React inputs. Use selector-based typing when necessary (for example `#identifier-field` and `#password-field`) and verify that the signed-in state actually changed before continuing.
- Every UI fallback must be explicitly reported with step number + reason.
- After any write (API or UI), perform API readback verification whenever possible.

## Progress Reporting (mandatory)
During execution, emit concise live status updates after each major phase using numbered checkpoints:
- `1/15 ...` through `15/15 ...`
- Every operator-visible progress/status message during the pipeline must begin with one of:
  - `N/15 ... Next: ...`
  - `Blocked at N/15: ... Next: ...`
- Every progress update must state both:
  - the **current step** being executed now
  - the **next step** that will run immediately after
- Preferred format:
  - `N/15 <current task>. Next: <next task>.`
- Do not send free-form milestone/status lines that omit the step number or omit `Next:`
- Include concrete outputs as soon as available (repo URL, Render URL, Sundai URL)
- If blocked, report exact blocker and current step number
- If blocked, also state the intended next action after the blocker is cleared
- Do not stay silent for long-running phases; send periodic progress updates

## Runtime communication (mandatory)
- Be verbal while running the pipeline.
- Print checklist progress as steps complete (e.g., `✅ 3/15 Repo created`, `🔄 7/15 Publishing`, `⚠️ 10/15 Smoke test failed, retrying`).
- For Telegram/chat runs, prefer compact operator-style updates such as:
  - `1/15 Researching approved projects. Next: score 3 ideas.`
  - `3/15 Deploying to Cloud Run. Next: capture demo URL.`
  - `Blocked at 3/15: Cloud Run denied for project X. Next: retry in project Y.`
- For Telegram/chat runs, keep updates short and plain; avoid extra paragraphs unless returning final artifacts.
- **Do not skip or renumber steps**; execute strictly in order and report every step.
- Send concise milestone updates during long runs, not just a final summary.
- End with a compact checklist recap showing status for each major step.
- **Share links immediately when available** (GitHub repo, deploy URL, Sundai project URL) instead of waiting for final summary.

## Workflow (always in order)

1. **Research-informed ideation (mandatory)**

   Execute 5 phases in sequence. Phases 2–5 are pure reasoning (no tool calls).

   **Phase 1 — DISCOVER: Real-world signal scan**

   The sole purpose is to gather raw material about **real problems people have right now**.

   - **Primary research (web search — this drives ideation):**
     - Conduct 2–3 targeted web searches to surface:
       - Acute pain points and workflow breakdowns across domains (dev tools, productivity, creative work, education, business ops, personal life)
       - Recent AI product launches, failures, and community frustrations from the last 7–14 days — what's generating heat, what's disappointing users, what gaps people are vocal about
       - Manual or tedious processes ripe for AI-native reinvention — expensive services that could be democratized, expert tasks that could be made accessible
     - If web search is unavailable or rate-limited, do not block the run. Fall back to reasoning from training knowledge about real-world pain points and market gaps. Report the blocker in progress output and continue.
   - **Deduplication fetch (API — not for inspiration):**
     - Fetch latest 100 approved Sundai projects from `https://www.sundai.club/api/projects?status=APPROVED`
     - Extract titles and one-line descriptions into a **dedup list** used only in Phase 3 to filter out overlapping ideas
     - Do not analyze these projects for engagement patterns, themes, or inspiration
   - **Phase 1 output — "Signal Brief":**
     - 5–10 specific real-world pain points with context (who suffers, what breaks, why current solutions fail)
     - 3–5 market shifts or emerging opportunities creating new solution space
     - Sundai dedup list (titles + descriptions, for later filtering only)

   **Phase 2 — DEFINE: Problem space framing**

   Before generating any solutions, define problems worth solving.

   1. From the signal brief, select **5 high-potential problem spaces** where pain is acute, timing is right, and AI can provide a step-change improvement.
   2. For each, write a **"How Might We" statement**: "How might we help [specific person] who [concrete situation/pain] to [desired outcome]?"
   3. For each, write a **Job-to-Be-Done statement**: "When [situation], I want to [motivation], so I can [outcome]."
   4. For each, articulate the **current alternative and its gap**: "Today they [workaround/existing tool], but it [specific limitation — slow, expensive, requires expertise, error-prone, etc.]."
   5. Apply a **feasibility gate**: Can this problem be meaningfully addressed with a demoable AI-powered MVP built in a single autonomous run using free models? Discard any that cannot.
   - **Phase 2 output:** 3–5 validated problem frames, each with HMW + JTBD + current alternative + gap + feasibility confirmation.

   **Phase 3 — DEVELOP: Divergent idea generation**

   Generate a broad set of solution concepts using multiple creative lenses, then cull aggressively.

   - **Divergent pass — generate 6–15 raw concepts:**
     - For each of the 3–5 problem frames, generate 2–3 solution concepts. Each concept must come from a **different creative lens** (do not reuse the same lens consecutively):
       - **Analogical transfer:** What solves a structurally similar problem in a completely different domain? Transpose that pattern into an AI-native solution.
       - **10x lens:** What would a solution look like if it were 10x better than the current alternative, not 10% better? What would have to change fundamentally?
       - **First principles decomposition:** Strip the problem to irreducible atoms. What is the minimum thing that must happen for the user to get value? Build up AI-native from the ground up.
       - **Constraint-based invention:** Force an unusual constraint ("must deliver value in under 10 seconds," "no text input," "combine two unrelated AI capabilities," "works with a single API call") and let it drive novel design.
   - **Convergent pass — cull to 5 candidates** via hard gates:
     - Not buildable as a demoable MVP in one autonomous run → cut
     - Too similar to an existing Sundai project on the dedup list → cut
     - AI is not the core value driver (could work equally well without AI) → cut
     - Is a generic chatbot, wrapper, or "ask AI about X" pattern with no distinctive interaction model → cut
     - Cannot be understood from a title and one sentence → cut
   - **Phase 3 output:** 5 candidate concepts, each with: working title (≤32 chars), one-line description (≤100 chars), which problem frame it addresses, which creative lens generated it, why AI is essential.

   **Phase 4 — DELIVER: Scoring and stress-testing**

   - **Pass 1 — Rubric scoring** (1–5 each, max 35):
     - **Real-world urgency:** How acute is the underlying pain? Are people actively seeking solutions?
     - **Novelty:** Is this genuinely new — not a rehash of common AI demo patterns (chatbot, summarizer, image generator)?
     - **Demo wow factor:** Would someone say "whoa" within 2 minutes of trying it?
     - **Feasibility:** Can this be built, deployed, and demoed in one autonomous run with free AI models?
     - **Value clarity:** Can someone immediately understand the benefit from the title and a 10-second interaction? Feature → capability → benefit → outcome must be self-evident.
     - **Job fit:** Does this clearly accomplish a job someone is actively trying to do? Would a real person switch from their current approach?
     - **Shareability:** Would someone show this to a friend or post about it? Is there a natural "you have to see this" moment?
   - **Pass 2 — Pre-mortem on top 2 candidates:**
     1. "Imagine nobody tries the demo and it gets zero engagement. What went wrong?" — 3 specific failure reasons each.
     2. "What is the single riskiest assumption this idea depends on?" — one sentence.
     3. "Can the MVP design itself mitigate that risk?" — yes/no with a concrete mechanism.
   - **Selection:** Pick the candidate that scores highest AND survives pre-mortem without a fatal, un-mitigable flaw. If top scorer has a fatal flaw, take the runner-up. If both finalists have fatal flaws, return to Phase 3 pool.
   - Selected idea must meet all of: clearly differentiated from common AI demo patterns; demoable in minutes by a first-time user; creative and ambitious; rooted in a real pain point surfaced during research; AI is essential and central.
   - **Override:** If user already gave a fixed idea, skip Phases 1–4 and proceed directly to Phase 5.

   **Phase 5 — PACKAGE: Structured handoff to Step 2**

   Format the selected idea for direct consumption by Step 2 when writing `spec/spec.md`:

   ```
   IDEATION OUTPUT
   Title: [≤32 chars]
   Description: [≤100 chars]

   Spec Seed:
   - What it does: [2–3 sentences]
   - Who it's for: [specific target user and their situation]
   - Core job: [JTBD one-liner from Phase 2]
   - Current alternative: [what people do today and why it falls short]
   - Key differentiator: [the single thing that makes this unlike anything else]
   - AI integration: [how AI is core to the product's value — which capability, how surfaced to user]
   - Demo flow: [3–5 step user journey for the smoke test in Step 11]
   - Tech stack suggestion: [frontend + backend + AI provider/model]
   - Riskiest assumption: [from pre-mortem — what could kill this + how MVP mitigates it]
   Engagement hook: [one sentence — why someone would click and try the demo]

   Design Direction:
   - Visual style: [one of: minimal, bold, playful, editorial, dashboard]
   - Reference design system: [pick from references/design-systems.md — e.g., "Dev Tool (Linear-inspired)" for dev tools, "Fintech (Stripe-inspired)" for business tools, "AI Platform (Claude-inspired)" for AI apps]
   - Color palette: [pick from references/design-palettes.md or specify custom — list 5 hex colors: primary, secondary, accent, background, text]
   - Font pairing: [heading font + body font from Google Fonts]
   - Layout: [single page scroll / sidebar dashboard / multi-page app]
   - Key polish target: [the one screen or interaction that must feel premium]
   ```

   - Title ≤32 chars and description ≤100 chars are hard limits enforced by Sundai.
   - Design Direction must reference a specific design system and palette — do not leave generic or "TBD". The Fabro build and polish steps use these values to produce polished UI.

2. **Create NEW GitHub repo + bootstrap all external surfaces first**
   - Create a **new public GitHub repo** for the project (no reusing old project repos), but do **not** try to `gh repo create --push` from a truly empty repo.
   - First create a minimal scaffold locally (for example: `README.md` and `.gitignore`), make an initial commit, and only then create/push the repo.
   - Recommended sequence:
     1. Initialize the local repo and write a minimal `README.md` + `.gitignore`.
     2. Commit the initial scaffold locally.
     3. Create the GitHub repo and push that initial commit.
     4. Capture the public repo URL immediately.
   - **Then provision the demo surface before Fabro starts**:
     1. Create a minimal placeholder app/shell if the repo has no deployable artifact yet.
     2. Deploy that placeholder immediately using **GCP Cloud Run by default** (static-only repos may use GitHub Pages when Cloud Run is unnecessary).
     3. This early deploy is meant to reserve a stable demo URL/service while Fabro is still building the real app.
     4. For any `gcloud` deploy/build command, always pass explicit flags:
        - `--project "$GCP_PROJECT_ID"`
        - `--region "$GCP_REGION"`
     5. Do not rely on the VM's default `gcloud` project/region config for deploys.
     6. Capture the live early `Demo URL` as soon as it exists.
   - **Then create the Sundai draft before Fabro starts**:
     1. Reuse the authenticated Sundai browser/API session.
     2. Create the project draft immediately with title, one-line description, launch lead, team member **vyahhi**, start date, GitHub URL, and the early Demo URL.
     3. Immediately fill the **full description** using the already-known idea/spec seed; do not leave the draft looking empty while Fabro runs.
     4. Add/generate the thumbnail early.
     5. Apply the bot's self-like early as part of draft setup, then verify it persisted.
     6. Save and verify the draft, but do **not** publish yet.
   - **Then sync lightweight GitHub + docs metadata before Fabro starts**:
     1. Fill the GitHub repo **About** section early: set the repo description, set `homepage` to the Sundai project URL, and add initial repo topics/tags.
     2. Update `README.md` early with the required Sundai lines and basic ship metadata while the build is still pending.
     3. The README must already include:
        - What it does (short description)
        - How to Run (from zero): prerequisites, `git clone`, `cd`, dependency install, run command, local URL
        - Limitations / known gaps
        - `Build on Sundai Club on Month D, YYYY`
        - `Sundai Project: <Sundai Project URL>`
        - a provisional/published links section that at least includes repo URL, Sundai URL, and the early demo URL
     4. Keep the Sundai date line and project URL on separate rendered lines.
     5. Add a minimal `.env.example` early with the expected runtime variables (`OPENROUTER_API_KEY`, `OPENROUTER_MODEL`, `OPENROUTER_BASE_URL`, `PORT`, and any app-specific required vars already known).
     6. Add an early deploy template/script (`scripts/deploy.sh` or an equivalent exact documented command) before Fabro starts so deployment details are not invented late.
     7. Fill Sundai tech tags and domain tags early when the category is already obvious from the idea.
     8. Commit and push these lightweight README/About/bootstrap updates before Fabro starts; do not defer them to the end.
   - Goal: while Fabro is building, the repo, deploy target, demo URL, and Sundai project should already exist **and the draft should already show description, thumbnail, self-like, GitHub About metadata, README Sundai info, tags, and bootstrap docs/env/deploy scaffolding**.

3. **Generate OpenSpec artifacts and hand implementation to Fabro**
   - After the repo/demo URL/Sundai draft exist, make the run **OpenSpec-first**:
     1. Initialize OpenSpec in the repo if needed.
     2. Create a change whose kebab-case name matches the project slug/title.
     3. Generate the four core artifacts: `proposal.md`, `design.md`, `specs/.../spec.md`, and `tasks.md`.
     4. Keep them concise but real; they should capture product intent, scope, decisions, requirements, and implementation tasks.
     5. If the repo already contains OpenSpec artifacts, update them instead of duplicating them.
     6. Commit and push the OpenSpec artifacts before Fabro starts.
   - Then hand the implementation to Fabro via the corrected generic-build path:
     1. Write a bridge file at `spec/spec.md` summarizing: project name, what it does, tech stack, AI integration requirements, demo flow, the OpenSpec change name, and the chosen Design Direction.
     2. Commit and push `spec/spec.md` together with the OpenSpec artifacts so GitHub reflects the intended build inputs before the long Fabro run starts.
     3. Copy the `fabro/` directory and `fabro.toml` from this workspace into the new repo.
     4. Write `fabro/workflows/generic-build/runs/sundai-ship.toml` with:
        - `graph = "../workflow.fabro"`
        - `app_dir = "."`
        - `spec_dir = "openspec"`
        - `workflow_dir = ".workflow"`
     5. Run: `fabro validate fabro/workflows/generic-build/workflow.fabro`
     6. Run: `fabro run fabro/workflows/generic-build/runs/sundai-ship.toml --preflight --sandbox local`
     7. Run: `fabro run fabro/workflows/generic-build/runs/sundai-ship.toml --auto-approve --sandbox local`
     8. This executes the corrected plan → implement → review → verify pipeline automatically for repo-root or nested-app repos.
     9. If the repo uses `fabro/workflows/sundai-ship/workflow.fabro`, the added design-skill prompts (`prompts/polish.md` and `prompts/design-check.md`) can use the spec's Design Direction to do an extra polish / design quality pass after a clean build.
   - Preferred implementation pattern:
     - OpenSpec defines the product and requirements.
     - `spec/spec.md` gives Fabro a compact execution brief.
     - Fabro implements the MVP from those specs.
   - If OpenSpec setup fails, report that exact blocker and continue with the previous direct `spec/spec.md` + Fabro/manual path so the project still ships.
   - If `fabro` is not available or fails, fall back to building the MVP manually (scaffold code directly), but still keep the OpenSpec artifacts in the repo.
   - **Mandatory:** each project must use AI in-product via OpenRouter **free** models.
   - Use this provider config (from environment variables, never hardcode secrets):
     - `OPENROUTER_BASE_URL=https://openrouter.ai/api/v1`
     - `OPENROUTER_MODEL=<free model from openrouter/free>`
     - `OPENROUTER_API_KEY=<secret>`
   - Implement at least one real LLM call in the app flow (not mock/rules-only).
   - AI must be **user-facing and core to value** (not hidden test endpoint only).
   - Render AI responses in a human-friendly UI format (markdown/rendered text), not raw/plain unformatted dumps.
   - Reject ideas that can be delivered equivalently without AI.

4. **Promote the Fabro result and redeploy onto the pre-created service**
   - After Fabro finishes successfully, promote/copy the generated app into the repo and push.
   - Redeploy the real app onto the **same existing service/demo URL** created earlier whenever possible.
   - Capture the final deployed revision/reference.
   - Do **not** create the deploy target late unless the early bootstrap failed and you explicitly log that fallback.

5. **Patch final Sundai details after the real app is live**
   - Use API update for project fields by default using authenticated browser session cookies.
   - Treat the early draft as already publicly presentable; this late step should mostly patch changed links/body details, not add the first description/thumbnail/like from scratch.
   - Prefer `SUNDAI_COOKIE_HEADER` when present; only derive cookies from the browser profile if the env header is absent or expired.
   - Read current project first and preserve `participants` in PATCH payload unless intentionally changing team.
   - Do not send empty `participants` by default.
   - Update/persist at minimum:
     - GitHub URL
     - Demo URL (final live app URL; often same as the early placeholder URL)
     - One Sentence Description
     - Full Description
     - Start Date
   - In **Full Description**, use real paragraph breaks (actual newlines), never literal `\n`.
   - If API update fails, use UI edit flow as fallback.

6. **Required defaults for every project**
   - Ensure team member **vyahhi** (Nikolay Vyahhi) is present.
   - If API member assignment does not persist, immediately use UI `+ Add Team Members` fallback and re-save.
   - Thumbnail flow is **API-first mandatory**:
     1) `POST /api/projects/{projectId}/generate-images` with `{ "prompt": "..." }`
     2) poll up to **120s** (every **5s**) for returned `images[]`
     3) take `images[0]`
     4) fetch `images[0]` as blob/file and send it as FormData key `thumbnail` in `PATCH /api/projects/{projectId}/edit`
     5) verify persisted via `GET /api/projects/{projectId}` (`thumbnailId` non-empty / updated)
   - UI thumbnail picker is fallback-only with explicit reason logging.
   - If API generation fails, fallback to existing thumbnail state and continue.

7. **Post-save verification (mandatory)**
   - Verify persisted fields via API readback first; use UI reload check as fallback.
   - Verify all are still present (not empty/null):
     - GitHub URL
     - Demo URL
     - Full Description
     - Team member `vyahhi`
     - Thumbnail present
   - If any field is missing, patch again and re-verify before publish.
   - Do **not** report the project as done just because create/save succeeded.

8. **Publish/submit (cookie-backed API mandatory-first)**
   - Use `PATCH /api/projects/{projectId}/submit` with JSON body `{ "status": "APPROVED" }` by default.
   - Prefer `SUNDAI_COOKIE_HEADER` when present; on `401`, report expired auth and refresh/reacquire the cookie header before UI fallback.
   - Treat 200 as success.
   - If API is non-200, verify publish state.
   - Verification order:
     1) check project page state (`Delist` visible) OR
     2) check project metadata indicates submitted/published.
   - If not published after verification, use UI Submit button as fallback.

9. **Like your own project (mandatory)**
   - On the project page, click the heart/Like button.
   - Verify liked state (active heart and/or incremented like count).

10. **Immediate link sync (mandatory, before health wait)**
   - As soon as a deploy URL exists, update external cards/links first:
     - Set Sundai `Demo URL` to deployed URL (API-first), save + verify persisted.
     - Re-verify GitHub About and README still reflect the correct Sundai/live links after final deploy; patch only if something changed.
   - Report these links immediately in progress updates.

11. **One-click demo test (mandatory, runs later)**
   - Run a demo smoke test after link sync:
     - `curl -I -L <Demo URL>` returns 200-range status
     - homepage loads in browser without obvious runtime error
     - at least one key interaction path works
     - at least one **AI-backed** interaction path works end-to-end
   - For AI verification, capture concrete evidence (response snippet or server/API success signal).
   - If AI call fails due model/provider issue, switch to another OpenRouter free model and retry before finalizing.
   - If deployment is still warming, wait/retry and report `waiting for live health` status.
   - If smoke test fails after retries, fix and redeploy before finalizing.

12. **Finalize publish surface checks (hard completion gate)**
   - Reload the **public project page** after the last save/publish action.
   - Confirm project remains published (`Delist` visible) and links still intact after health checks.
   - Public-page QA must confirm all of the following are visibly present on the live page/card before declaring completion:
     - GitHub link visible
     - Demo link visible
     - Full description renders (not `null`, not empty)
     - Team section includes `vyahhi` / Nikolay Vyahhi
     - Thumbnail is visible
   - If any public-page item is missing, return to edit mode, fix it, save again, and repeat the public-page QA.
   - Never tell the user the Sundai project is finished until this public-page QA passes.

13. **Update GitHub README + lint**
   - README/About/bootstrap-doc requirements are **front-loaded before Fabro**; this late step is a final audit, not the first time those sections are added.
   - Ensure README still includes required sections, published-links block, and any early bootstrap docs/env/deploy notes added before Fabro:
     - What it does (short description)
     - **How to Run (from zero)** with full local setup steps:
       1) prerequisites
       2) `git clone <repo-url>`
       3) `cd <repo-folder>`
       4) dependency install (if any)
       5) run command
       6) local URL to open
     - Limitations / known gaps
   - Ensure the two separate Sundai lines are still present in `README.md`:
     - `Build on Sundai Club on Month D, YYYY`
     - `Sundai Project: <Sundai Project URL>`
   - Date must be human-readable (example: `March 8, 2026`), not ISO format.
   - **Mandatory markdown formatting:** force a rendered line break between them (use either two trailing spaces on the date line or a blank line between lines) so it never collapses into one line.
   - Keep project URL on its own line, separate from the date line.
   - Commit and push the README change.

14. **Version + changelog (mandatory)**
   - Keep API payload schemas current in `references/sundai-api-mode.md` when Sundai behavior changes.
   - Keep a pipeline version and changelog at `references/changelog.md`.
   - On every pipeline rule change, append:
     - date/time
     - version bump (semantic or incremental)
     - concise list of changed rules
   - Mirror updated skill files to `sundaiclaw/hacker`.

15. **Return final artifacts**
   - Reply only after the hard completion gate above passes.
   - Reply with:
     - GitHub repo URL
     - Sundai project URL
     - Deploy URL (Cloud Run or Pages)
     - Publish status confirmation
     - AI verification note (which model + proof that user-facing AI path worked)

## Fast command interpretation
When user says short commands like:
- “create Sundai project for X”
- “ship this to Sundai”
- “do the Sundai pipeline”

Interpret as: run the full workflow above, including team member, post-save verification, publish, and GitHub About/README sync.

## Local Environment (required)
- Ensure local env file exists at workspace root: `.env.sundai`.
- Required keys:
  - `OPENROUTER_API_KEY`
  - `OPENROUTER_BASE_URL=https://openrouter.ai/api/v1`
  - `OPENROUTER_MODEL` (must be a free model from `https://openrouter.ai/openrouter/free`)
  - `GCP_PROJECT_ID`
  - `GCP_REGION` (recommended default: `us-central1`)
- Preferred Sundai auth keys:
  - `SUNDAI_COOKIE_HEADER` for cookie-backed API mode
  - `SUNDAI_USERNAME`
  - `SUNDAI_PASSWORD`
- Always load env first in runs (e.g., `set -a; source .env.sundai; set +a`).
- Load these vars before running local tests/deploy scripts.
- For `gcloud` commands, prefer explicit flags sourced from env:
  - `--project "$GCP_PROJECT_ID"`
  - `--region "$GCP_REGION"`
- Never commit API keys into repo code/README.

## Reference
- Use `references/checklist.md` as a run checklist and copy-safe description template.
- Use `references/ai-endpoint.md` for OpenRouter integration snippet/pattern.
- Use `references/sundai-api-mode.md` for API-first request patterns and fallback rules.
- Borrow OpenSpec artifact quality/shape from `../openspec-workflow/SKILL.md` when drafting proposal/design/specs/tasks for a Sundai repo.