You are setting up a new AI agentic-engineering project for me, backed by Open Source Cloud (OSC). Follow these steps in order. Do not write application code yet, this step only connects OSC, asks me what we are building, and creates the team.

STEP 0 - Connect OSC (hard gate).
Call the OSC MCP tool `get-mcp-help`. If it returns the OSC onboarding doc, OSC is connected, continue.
If the tool is missing, STOP and tell me to add it, then wait for me to re-paste:
  - Claude Code: run `claude mcp add --transport http osc https://mcp.osaas.io/mcp` (or add an HTTP MCP connector named `osc` at https://mcp.osaas.io/mcp in Settings), complete the OAuth login, then run `/mcp` to confirm.
  - Codex: there is NO `codex mcp add` for remote servers (that subcommand is stdio-only). Add this block to `~/.codex/config.toml` (or `.codex/config.toml` to scope it to one project), then start Codex, complete the OAuth login, and run `/mcp` to confirm:
    [mcp_servers.osc]
    url = "https://mcp.osaas.io/mcp"

STEP 1 - Understand the project.
Ask me, one question at a time: (a) what am I building and for whom, (b) the one success metric, (c) which surfaces it needs (backend API, web frontend, mobile, data pipeline, MCP server), (d) the time horizon (proof of concept, MVP, production). Propose a sensible default for each and let me accept or change it.

STEP 2 - Build the agent team (use your tool's native convention).
Create a full engineering team. In Claude Code, write one sub-agent file per role under `.claude/agents/<role>.md` with name, description, model, and a minimal tool list. In Codex, define the same roles in `AGENTS.md` and adopt the right role per task.

Mandatory roles: architect, backend, frontend, reviewer, qa, pm, ux, security, and a team-lead (orchestrator for work spanning 3 or more subtasks). Add a domain-specialist role for each real domain in my project (payments, video, auth) and a user-persona role for each distinct end user.

Team rules (bake these into every role and into CLAUDE.md or AGENTS.md):
  - Default every role to the latest model. Security stays on a non-Opus model with high reasoning effort.
  - The reviewer NEVER writes or edits what it reviews, but it CAN run read-only checks to verify against ground truth.
  - Verify before claiming: read the relevant source before writing code that depends on it.
  - After any agent opens a pull request, the reviewer runs automatically before done. Reviewing is not skippable.
  - Never force-push, hard-reset, or run destructive git.
  - Acceptance criteria live in each task, not in the role files. Keep role files timeless.

STEP 3 - Write CLAUDE.md (and AGENTS.md) with the project purpose, the success metric, the team roster, and the rules above. Then stop and tell me to paste Prompt 2.

Act as the architect agent. Decide the Open Source Cloud stack for this project and record it as an Architecture Decision Record, ADR-001.

1. Re-read CLAUDE.md or AGENTS.md and the project purpose.
2. Call `list-service-categories` (live, never trust a cached count) and `list-available-services` to see what OSC offers today. Call `ask-osc-architect` with my problem for guidance, and `list-solutions` or `describe-solution` to check for a pre-baked fit.
3. Propose the stack: which OSC catalog services back this project (database, cache, object storage, search, auth, analytics), whether the app runs as an OSC My App, and whether to enable Agentic SDLC. For each choice give a one-line reason. Flag anything OSC does NOT cover today as an open question, do not invent a service.
4. Write it to `docs/architecture/ADR-001-osc-stack.md` (Context, Decision, Consequences, Alternatives). Show me the summary and wait for my approval before anything is provisioned.

Act as the team-lead. Execute ADR-001's deploy plan on OSC. Backing services and the app run ON OSC from day one, not later, no long-lived local docker as the default backend.

1. `setup-parameter-store` (one store for this project).
2. For each backing service in ADR-001: `create-service-instance`, then `set-parameter` for its connection string (DATABASE_URL, REDIS_URL). `create-storage-bucket` if object storage is in the ADR. `schedule-backup` before any service holds real data.
3. Have the dev agents build the smallest end-to-end slice that proves the app works against those OSC services.
4. Push the code to my git repo, then `create-my-app` pointed at it and `wait-for-app-ready`. This deploy is the moment my OSC workspace goes live.
5. If ADR-001 chose it, `enable-agentic-sdlc` so the app can keep maintaining itself.
6. Report the live app URL and what each agent did.